﻿//Default units used in these constants:
//time: seconds
//distance: tiles

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	REGIONAL SETTINGS! IMPORTANT: THESE NEED TO MATCH PARAMS.SFO (FOR PS3 ANYWAY)
//
> REGIONAL

int ONLINE_MINIMUM_AGE_US = 6 // note: the game is E for everyone but online interactions are 6+ anyway (see https://ps3.scedev.net/support/issue/128197/_R040_Online_Age_Rating)
int ONLINE_MINIMUM_AGE_EU = 3 // PEGI 3+
int ONLINE_MINIMUM_AGE_DEFAULT = 0

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	DEBUGGING
//
> Debugging

string FIRST_MENU = "mainmenu"

bool DISABLE_MACHINES = false //false
bool DISABLE_SECRET_MEN = false //false
bool DISABLE_LIMBO = false //false

float DECORATION_SHADER_UPDATE_WIDTH = 50

// any objects further than this from the camera wont get updated //qqq not really a debugging const
float MAX_UPDATE_DISTANCE_FROM_CAMERA = 250

// set to 2 or more or things will go HORRIBLY WRONG //qqq not really a debugging const
int MAX_NUMBER_OF_CHUNKS_TO_KEEP_IN_MEMORY = 3 //3

// enable jumping when on a tiktak?
bool ENABLE_JUMP_ON_TIKTAK = false

// PC only, true will put it in trial/demo mode
bool FORCE_TRIAL = false

// these constants spread the spawning of the objects over a few frames for optimization
bool ENABLE_DELAYED_GAMEOBJECT_SPAWNING = false
bool ENABLE_DELAYED_DECORATION_SPAWNING = true

// if false it will just restart the default level
bool KEYBOARD_USE_CABINET_MAPPING = false

// for testing complicated xbb interactions over the network
bool SPAM_XBB_STATUS_OUTPUT = false

// show the build nr in the main menu
bool SHOW_REVISION_NUMBER = false

/////////////////////////////////////////////////////////////////////////////////////////////////////////
// affects all the items below this one,
// any items above will still work! 
/////////////////////////////////////////////////////////////////////////////////////////////////////////
bool DISABLE_ALL_DEBUG_STUFF = true

bool TWITCH_BUILD = false // disables mouse trail and enables fullscreen windowed mode
bool ANIME_MODE = false
float ANIME_MODE_SIZE_MODIFIER = 3

bool GO_STRAIGHT_TO_GAME = false // will also enable splash screen skipping when true
bool SKIP_SPLASH_SCREENS = false
bool DISABLE_PRELOADING = false

bool START_WINDOWED = false
bool SHOW_MOUSE_CURSOR = false

bool NO_STEAM_BUILD = false

bool GUEST_ACCOUNTS_UNLOCK_EVERYTHING = false
bool ALL_ACCOUNTS_UNLOCK_EVERYTHING = false
bool RESET_SAVEGAMES = false

bool SOAK_TEST = false
float SOAK_TEST_SPEED = 400
bool CONTINUOUS_RESTART = false // requires SOAK_TEST
bool SOAK_DYNAMIC_SPEED_CALCULATION = false
float SOAK_DURATION = 5 // in minutes, will only work if SOAK_DYNAMIC_SPEED_CALCULATION is true

// clear the whole background each frame before drawing (draws the pink background of death when outside the level bounds)
bool CLEAR_BACKGROUND = false //false

// disable stuff
bool DISABLE_PARTICLES = false
bool DISABLE_TRAIL = false
bool DISABLE_ANIMATION = false
bool DISABLE_VIBRATION = false
bool SKIP_MODEL_UPDATE = false
bool MUSIC_DISABLED = false
bool SFX_DISABLED = false

// allow cheats/debugger options
bool ENABLE_CONSOLE = false // you can also just hit 'c' to disable it in-game
bool ALLOW_FLOW_CHEATS = false
bool VIEW_BOUNDING_BOXES = false
bool SLOW_DOWN_NETWORK_WHEN_NOT_IN_GAME = false
bool PROFILE_SOUND = false
bool ENABLE_DIAMOND_POINTER = false

// slow motion (or fast forward) enabling variables
float SERVER_TIME_MODIFIER = 1
float CLIENT_TIME_MODIFIER = 1

// output
bool ENABLE_PHOTON_DEBUG_SPAM = false
bool ENABLE_SFX_LOGGING = false
bool TEST_TOTEM_DANCES = false

// controller mapping (for when the game directly starts using constants.txt)
bool CONTROLLER_USE_SINGLE_PLAYER_MAPPING = false

// additional load time, use to test background loading
int FAKE_LOAD_TIME_REMOTE_ONLY = 0
int FAKE_LOAD_TIME = 0

// logging
bool LOG_TEXTURE_LOADS = false
bool LOG_SCRIPT_LOADS = false
bool LOG_FILE_ACCESS = false
bool LOG_SHADER_CREATION = false
bool LOG_MODEL_LOADS = false
bool LOG_ANIMATED_MODEL_LOADS = false
bool LOG_GLYPHSET_LOADS = false

// can be enabled manually by pressing G
bool INVULNERABILITY = false
// can be enabled manually by pressing V
bool ENEMY_INVULNERABILITY = false

string QUICK_LEVEL_LOAD_1_1 = "level1-1.txt"
string QUICK_LEVEL_LOAD_1_2 = "level1-2.txt"
string QUICK_LEVEL_LOAD_1_3 = "level1-3.txt"
string QUICK_LEVEL_LOAD_2_1 = "level2-1.txt"
string QUICK_LEVEL_LOAD_2_2 = "level2-2.txt"
string QUICK_LEVEL_LOAD_2_3 = "level2-3.txt"
string QUICK_LEVEL_LOAD_3_1 = "level3-1.txt"
string QUICK_LEVEL_LOAD_3_2 = "level3-2.txt"
string QUICK_LEVEL_LOAD_3_3 = "level3-3.txt"
string QUICK_LEVEL_LOAD_4_1 = "level4-1.txt"
string QUICK_LEVEL_LOAD_4_2 = "level4-2.txt"
string QUICK_LEVEL_LOAD_4_3 = "level4-3.txt"
string QUICK_LEVEL_LOAD_5_1 = "level5-1.txt"
string QUICK_LEVEL_LOAD_5_2 = "level5-2.txt"
string QUICK_LEVEL_LOAD_5_3 = "level5-3.txt"

string QUICK_LEVEL_LOAD_6 = "world_work.txt"
string QUICK_LEVEL_LOAD_7 = "chunks/w3_2_07000_bad.tmx"
string QUICK_LEVEL_LOAD_8 = "chunks/w0_limbo"
string QUICK_LEVEL_LOAD_9 = "chunks/ws_vert_01000_start.tmx"

string QUICK_LEVEL_LOAD_1 = "world1.txt" 
string QUICK_LEVEL_LOAD_2 = "world2.txt" 
string QUICK_LEVEL_LOAD_3 = "world3.txt" 
string QUICK_LEVEL_LOAD_4 = "world4.txt"
string QUICK_LEVEL_LOAD_5 = "world5.txt"

// Keyboard shortcuts

// Q: Restart
// P: Cave
// F: Flow
// R: Reload level & constants
// 1-9: Quick level load
// M: pause sound
// G: God mode
// ]: Collect Diamonds
// =: FPS display
// J: Change Score Level (Totem dance)
// B: Save database

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	DEMO
//
> Demo

// first shaman encounter
string SPEECH_COLOR_1 = "FFFFFF"
float SPEECH_SCALE_1 = 0.08

// second shaman encounter
string SPEECH_COLOR_2 = "121228" 
float SPEECH_SCALE_2 = 0.08

float START_DELAY = 15
float DEFAULT_REGION_TIME = 15 // default time for regions in the demo before it jumps to the next region. this can be overridden in the level itself.
float FADE_TIME = 0.3 // amount of time to lock the input for after a jump ( for example to make sure they land on a tiktak )
string FADE_COLOR = "FFFFFF"
float SPEECH_BUBBLE_X = -7 //-20
float SPEECH_BUBBLE_Y = -27
float TEXT_FADE_DURATION = 1
float OPTION_TEXT_FADE_DURATION = 1.0
float OPTION_TEXT_DELAY_DURATION = 2.0
float FIRST_SHAMAN_FLASHFORWARD_DELAY = 7 // The flash forward delay when we meet our first shaman

string SHAMAN_MESSAGE_01 = "shaman intermezzo"
string SHAMAN_MESSAGE_02 = "shaman text"


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	SPLASHSCREEN
//
> Splashscreen

string SCREEN1 = "splash ibb obb logo"
string SCREEN2 = "splash contributors"
string SCREEN3 = "splash none"
string BLANK = "splash none"

string INDICATOR_WARNING_IMAGE = "save_indicator_in_bubble"

float SCREEN_DURATION = 5
float MINIMUM_SCREEN_DURATION = 2
float BLACK_DURATION = 0.3
// If this is true then the player can skip splash screens by pressing any button.
// This also means if the player just hammers the buttons they'll never see any of the screens (apart from the save indicator one!) 
bool SKIP_SCREEN_ON_BUTTON_PRESS = true
// If the constant above is false then pressing any button will reduce the time a splashscreen is visible to the constant below
// This way the users can still speed up moving through the splash screens and not bypass them completely (by spamming button presses)
float REDUCED_SCREEN_DURATION = 0.2
float ESRB_DURATION = 4

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	NETWORK
//
> Network

// how often to check connection with psn
float CONNECTION_CHECK_INTERVAL = 3

string ROOM_NAME = "bensroom"

// use "best" as a special name to tell it to find the best one :D
string SERVER_ADDRESS =  "best" //"app-us.exitgamescloud.com"  // "192.168.10.171:5055" //
float PING_FREQUENCY = 1 // how many pings to send per second

float MAX_LAG = 1 // if packets are received with more delay than this, cap it

// the update rate determines how many times/sec a network message gets sent regardless of current state
float ENEMY_UPDATE_RATE = 2
float LEVELMAN_UPDATE_RATE = 1
float FIN_UPDATE_RATE = 10
float SECRET_MAN_UPDATE_RATE = 0
float CROW_UPDATE_RATE = 2
float DIAMOND_UPDATE_RATE = 15
float DIAMOND_RAIN_UPDATE_RATE = 2
float TOTEM_UPDATE_RATE = 2

// when we receive a packet for an object, we call update() on it with a time-delta equal to the lag
// if the lag is high, that means we do a very big update which we'd rather split into a couple of smaller ones.
// limit the update size to this "virtual fps"
float LAG_COMPENSATION_FPS = 10


// dynamic updates only get sent if the state has changed (mainly speed)
// this reduces network overhead
float XBB_DYNAMIC_UPDATE_RATE = 33
// xbbs also send messages regardless of state changes (just to be sure if something slips through the cracks ;))
float XBB_UPDATE_RATE = 15

// if the position we get from the network is more than this distance from our estimate, teleport (otherwise smooth)
float XBB_CLIENT_SMOOTHING_MAX_DISTANCE = 20
float XBB_CLIENT_SMOOTH_FACTOR = 0.999

// how often to send generic state updates
float GAMESTATE_UPDATE_RATE = 2

// network debugging related

bool CLIENT_SMOOTHING_ENABLED = true
float FAKE_UNRELIABLE_PACKET_DROP_RATE = 0.0 // between 0 and 1

// we keep a rolling average of message lag and remote time,
// this is the weight per received estimate:
float ROLLING_AVERAGE_FACTOR = 0.07

bool LOG_MESSAGES = false
// skip state updates for objects (as they spam the log a lot)
bool LOG_IGNORE_STATE_PACKETS = true

// update fins only when their speed differs more than this from the info we get over the network
float FIN_SPEED_DIFFERENCE_X = 1
float FIN_SPEED_DIFFERENCE_Y = 13

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	VOICECHAT
//
> VoiceChat

bool DISABLED = false

int SPU_LOAD_AVERAGE = 50
int MAX_PLAYERS = 2
int MAX_SPEAKERS = 2
bool ENABLE_VOICE_DETECTION = false
// Max Bitrate must be one of the following values:
// 4000, 8000, 16000, 20000, 24000, 28000
int MAX_BITRATE = 16000


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	LIMBO
//
> Limbo

float BUBBLE_GROW_TIME = 0.6
float BUBBLE_MAX_SIZE = 1.6

int LIMBO_MASK = 5
int LEVEL_MASK = 6


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	PHYSICS
//
> Physics

// when bouncing objects bounce back, just stop them if their speed < MINIMUM_BOUNCE_SPEED
float MINIMUM_BOUNCE_SPEED = 0.5

// when something hits the tiktak the speed given to objects depends on the relative weights
// however the maximum factor will be MAX_TIKTAK_BOOST, even if we weigh a ton :)
float MAX_TIKTAK_BOOST = 3
// minimum force required to trigger the tiktak
float TIKTAK_THRESHOLD_FORCE = 60

// reduction of the force if we jump on someone who is on a tiktak
// also used when two players go through a warp together!
float TIKTAK_FORCE_REDUCTION = 0.8

// stuff that is standing inside a vertical warp gets gently nudged out )
float VERTICAL_WARP_EXPEL_ACCELERATION = 100

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	GAME
//
> Game

int DISK_SPACE_REQUIRED_FULL = 1024 // saves are 1k so a meg should be enough for everybody. the secretman save file is also 1k (and there's only ever one copy of it)
int DISK_SPACE_REQUIRED_TRIAL = 0 // can't save in trial mode anyway

// when one player dies, the other will die after TIME_TO_DEATH seconds
float TIME_TO_DEATH = 1
// then, TIME_TO_ENEMY_DEATH later, all enemies will die
float TIME_TO_ENEMY_DEATH = 0.5
// finally, TIME_TO_RESPAWN seconds after that, both players respawn again
float TIME_TO_RESPAWN = 0.5

float MODEL_SCALE = 0.135 //scale for ibb and obb
float RESPAWN_TIME = 1 // after 1 second of ibb and obb being dead, respawn them
float RESPAWN_HEIGHT = 100 // how high we respawn (measured from the checkpoint's y)

float FLOW = 0 // initial flow value (toggle between 0 and 1 with the F key)

float DEFAULT_SCREEN_RESOLUTION = 780 //deals with the scaling of the particles

// if fps drops below this value, slow down the game (so that internally it is still running at this value)
float MINIMUM_FPS = 15

// if fps gets above this value, don't update
float MAXIMUM_FPS = 120

int PS3_CHUNK_THREAD_PRIORITY = 1500
int PS3_SYNC_THREAD = 3071

string DEFAULT_LANGUAGE = "en" // standard language codes: en, de, it, fr, es, ja

int NR_OF_SUPPORTED_JOYSTICK_SLOTS = 4

// if a chunk takes this long to load, throw it away and try again. last ditch failsafe against chunks not loading
float CHUNK_LOADING_TIMEOUT = 30

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	HOME REWARDS
//
> Home

// when you find ubb
string REWARD_UBB_COMPANION = "1362D2BC-6D05435B-A2F5438C-335768A5"

// when you boot the game
string REWARD_IBB_DRESS = "601A452E-6948417C-99B6D31A-DCECA3B2"
string REWARD_OBB_DRESS = "904DCDA2-B2264DE2-AEDF35CD-B4661BEF"
string REWARD_IBB_SWEATER = "E289B21C-ED074BAC-AD3F4CBA-E21374CD"
string REWARD_OBB_SWEATER = "5CB49D43-FE3D4349-82DF802C-3F85E8E6"

// find a secret level
string REWARD_IBB_LAMP = "903FC627-D7F94093-AE096558-C378E6C4"
string REWARD_OBB_LAMP = "E7B265FD-A04A48EC-96FF534E-6ADEB973"


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	DIRECTOR
//
> Director

// time to wait between the boss's death and fadeout
float INITIAL_WAIT_TIME = 5

float FADEIN_DURATION = 1 //Screen fader
float FADEOUT_DURATION = 1
float ZOOM_DURATION = 1
float ZOOMED_IN_AMOUNT = 12
float ZOOMED_OUT_AMOUNT = 200
float ZOOM_DELAY_TIME = 2 //Delay before zoomingout begins
float ZOOM_FINISHED_DELAY_TIME = 1 //Delay before lights come on after zooming out
float PARTY_TIME_THEME_DURATION = 1 //Palette changes
float CREDIT_SCROLLING_DELAY = 1 //Delay before credits scroll
float REMINISCING_START_DELAY = 16 //Delay before fade out and reminiscing starts
float REMINISCING_FINISH_DELAY = 1 //Delay before fade out to main menu
float CREDIT_REPOSITION_Y = 1.7 //Moves the credits down so they start off screen

float LOOK_AT_X_OFFSET = 10
float LOOK_AT_Y_OFFSET = 10
float LOOK_AT_DURATION_MIN = 2
float LOOK_AT_DURATION_MAX = 5

float CAMERA_PAN_SPEED = 20

float IBB_OFFSET_X = -3
float IBB_OFFSET_Y = 1.8
float OBB_OFFSET_X = 3
float OBB_OFFSET_Y = 0.9

int XBB_DANCE = 2
string LEVELMAN_DANCE = ""
int TOTEM_DANCE = 6

// color of credits when background fly-through is shown
string CREDIT_COLOR_1 = "FFFFFF"

// color of credits when background is black (fly-through has faded out)
string CREDIT_COLOR_2 = "FFFFFF"

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	TRANSITION
//
> Transition

float SPAWN_TIMER_MIN = 1  //Used for random timers - pretty obvious what they govern
float SPAWN_TIMER_MAX = 4

float REMOVE_TIMER_MIN = 1
float REMOVE_TIMER_MAX = 4

float QUICK_SPAWN_TIMER_MIN = 0.03
float QUICK_SPAWN_TIMER_MAX = 0.10

float QUICK_REMOVE_TIMER_MIN = 0.03
float QUICK_REMOVE_TIMER_MAX = 0.10

int INITIAL_SPAWN_COUNT = 15 //How many eyes at the start?

float EYE_WIDTH = 0.15 //The width of a set of eyes, used for placing new eyes so they don't appear on top of each other
float EYE_HEIGHT = 0.15
float BORDER_X = 0.1 //How far from the left and right of the screen can we place eyes
float BORDER_Y = 0.9 //How far from the top and bottom of the screen can we place eyes

float EYE_SIZE_MIN = 0.8
float EYE_SIZE_MAX = 1.4

float EYE_STANCE_WIDTH_MIN = 0.7
float EYE_STANCE_WIDTH_MAX = 1.8

int ROWS = 10
int COLUMNS = 10

float EYE_SCALE = 2 //The smaller the number the bigger the eyes

float OFFSET_X = 0.07 //Random x movement from -n to n - needs to be pretty small or they'll overlap and there's no checking for that now
float OFFSET_Y = 0.07

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	SCOREMAN
//
> Scoreman

int PLATINUM_LEVEL = 10
int GOLD_LEVEL = 8

float SCOREBOARD_SCALE = 0.8 //This changes the entire scoreboard

float MINIMUM_DISTANCE = 70 //How close players need to be to activate the levelman
float SCOREBOARD_FADEIN_TIME = 1.0 //Total time for the scoreboard to fade in to the gradient 
float SCOREBOARD_SCALING_TIME = 1.5 //Total time for the scoreboard to scale down
float SCOREBOARD_FADEIN_TEXT_TIME = 0.5 //Total time for the text to fade in
float SCOREBOARD_FADEOUT_TIME = 0.12 //Total time to fade out the scoreboard
float TRANSFORM_DURATION = 1.5 //Total time to change colour

float SCOREBOARD_WIDTH = 16 //Width of scoreboard
float SCOREBOARD_QUAD_HEIGHT = 12 //Height of quad in scoreboard
float SCOREBOARD_TRIANGLE_HEIGHT = 8 //Height of the triangle
float STARTING_OFFSET_Y = 26 //How far above the levelman center the center of the scoreboard starts
float ENDING_OFFSET_Y = 14 //How far above the levelman center the bottom of the scoreboard stops
 
string CONTENT_COLOR = 777777 //Colors for the items on the scoreboard (text, divider line, icon etc.)
string SCOREBOARD_COLOR = c8ecf5 //Colors for the scoreboard

float SCOREBOARD_ICON_SIZE = 3.0 //Diamond Icon
float SCOREBOARD_ICON_POS_Y = 3.0 //Relative to the top of the scoreboard (so this is 3 units down from the top point of the scoreboard)

float SCOREBOARD_TRINK_ICON_SIZE = 12.0 //Trink Icon
float SCOREBOARD_TRINK_ICON_POS_Y = 8.0 //Relative to the top of the scoreboard (so this is 8 units down from the top point of the scoreboard)

float SCOREBOARD_DIVIDER_SIZE_X = 10.0 //Divider Line
float SCOREBOARD_DIVIDER_SIZE_Y = 0.20
float SCOREBOARD_DIVIDER_POS_Y = 10

float SCOREBOARD_COLLECTED_TEXT_POS_Y = 7.0 //Top, large text
float SCOREBOARD_COLLECTED_TEXT_SCALE = 0.15 //0.09

float SCOREBOARD_ENCOUNTERED_TEXT_POS_Y = 11.8 //Bottom, smaller text
float SCOREBOARD_ENCOUNTERED_TEXT_SCALE = 0.10 //0.06

float SCOREBOARD_BOBBING_DISTANCE = 2 //How far to bob up and down
float SCOREBOARD_BOBBING_DURATION_MIN = 2 //For generating random values, min and max possible durations in seconds
float SCOREBOARD_BOBBING_DURATION_MAX = 3

int TRANSFORM_SWATCH_ID_X_GOLD = 19
int TRANSFORM_SWATCH_ID_Y_GOLD = 1

int TRANSFORM_SWATCH_ID_X_GOLD_SHADOW = 19
int TRANSFORM_SWATCH_ID_Y_GOLD_SHADOW = 2

int TRANSFORM_SWATCH_ID_X_PLATINUM = 19
int TRANSFORM_SWATCH_ID_Y_PLATINUM = 4

int TRANSFORM_SWATCH_ID_X_PLATINUM_SHADOW = 19
int TRANSFORM_SWATCH_ID_Y_PLATINUM_SHADOW = 5

int TRANSFORM_PARTICLE_COLOR_COUNT = 3 //How many different colors are available for the platinum scoreman particles

//Transform to this color from original before swapping to end color (gold/platinum/whatever)
int TRANSFORM_INTERLUDE_COLOR_X = 19
int TRANSFORM_INTERLUDE_COLOR_Y = 3

float TRANSFORM_MASS = 1 //For spawning the particles; a mass of 1 will spawn 240 particles

float JUMP_HEIGHT = 10

float TRANSFORM_REGION_DENSITY = 0.1
int TRANSFORM_REGION_OFFSET_X = 15
int TRANSFORM_REGION_OFFSET_Y = 10
int TRANSFORM_REGION_WIDTH = 30
int TRANSFORM_REGION_HEIGHT = 15

float SCOREBOARD_FADE_MIN_DISTANCE = 60 //How far away you have to move before the scoreboard starts to fade
float SCOREBOARD_FADE_MAX_DISTANCE = 85 //How far away you have to move before the scoreboard is completely invisible

string SCOREBOARD_DIAMOND_ICON_TEXTURE = "scoreboard_icon_diamond"
string SCOREBOARD_DIVIDER_TEXTURE = "white"
string SCOREBOARD_TRINK_COLLECTED_ICON_TEXTURE = "scoreboard_icon_secret_found"
string SCOREBOARD_TRINK_NOT_COLLECTED_ICON_TEXTURE = "scoreboard_icon_secret_missing"


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	TRAIL
//
> Trail

int PARTICLE_COUNT = 1000

float PARTICLE_SIZE = 10
float PARTICLE_SIZE_VARIATION = 0.5

float PACKET_DELAY = 0.07
// how many particles are created per 1 unit of length of the particle "ray"
float PARTICLE_DENSITY = 4

//Between 0 - 1     Beware: 1 will have you whizzing off screen with only the slightest mouse movement
float MOVEMENT_SENSITIVITY = 0.05
//For PS3
float MOVEMENT_SENSITIVITY_PS3 = 60

//How long to leave mouse/joystick before trail deactivates (stop spawning new particles)
float DURATION_OF_INACTIVITY_FOR_DEACTIVATION = 3

//Delay before the particle actually starts fading in
float PARTICLE_DELAY_MIN = 0
float PARTICLE_DELAY_MAX = 0.5

//Offset for position placement on the trail
float POSITION_OFFSET_X_MIN = -1.5
float POSITION_OFFSET_X_MAX = 1.5
float POSITION_OFFSET_Y_MIN = -1.5
float POSITION_OFFSET_Y_MAX = 1.5

//How long the particle lasts
float PARTICLE_LIFETIME_MIN = 1.5
float PARTICLE_LIFETIME_MAX = 3

//How long to fade in/out
float PARTICLE_FADE_DURATION_MIN = 0.1
float PARTICLE_FADE_DURATION_MAX = 0.5

float CURSOR_DISTANCE_BUFFER = 3

// When networking each client receives packets with the latest position
// of the other players' trails. These positions are then interpolated
// across to create the final image of the trail on screen. This constant
// dictates the intervals of the different positions when interpolating
// E.g. If the distance between the last 2 points is 20, and the interval constant is 1,
// then 20 random positions will be set between those 2 points for the trail nodes to spawn around
// amountOfPositions = (distance / interval)
float PARTICLE_INTERPOLATED_DISTANCE_INTERVAL = 10
// How many particles per trail node
int PARTICLE_COUNT_PER_NODE_MIN = 3
int PARTICLE_COUNT_PER_NODE_MAX = 3


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	CONTROLS
//
> Controls

// size of the deadzone (0 = stick is centered, 1 = stick fully extended)
float X_DEADZONE_SIZE_SINGLE_PLAYER = 0.2
float X_DEADZONE_SIZE = 0.2
float Y_DEADZONE_SIZE_SINGLE_PLAYER = 0.0
float Y_DEADZONE_SIZE = 0.5

float TRAIL_X_DEADZONE_SIZE = 0.2
float TRAIL_Y_DEADZONE_SIZE = 0.2

// if the stick is beyond FULL_SPEED_BUFFER then we count it as being fully extended
float X_FULL_SPEED_BUFFER_SINGLE_PLAYER = 0.6
float Y_FULL_SPEED_BUFFER_SINGLE_PLAYER = 1.0
float X_FULL_SPEED_BUFFER = 0.8
float Y_FULL_SPEED_BUFFER = 0.8

float TRAIL_X_FULL_SPEED_BUFFER = 1
float TRAIL_Y_FULL_SPEED_BUFFER = 1

// Y controls are digital
float DIGITAL_CROSSOVER_POINT_Y_SINGLE_PLAYER = 0.44
float DIGITAL_CROSSOVER_POINT_Y = 0.3

// How much of an "S" shape the stick/speed graph makes.
// 0 = linear
// 1 = maximum smoothing (ie speed increases slowly at start of spectrum, 
// then increases really quickly around the middle and then reaches max speed
// slowly again at the end).
float SMOOTH_FACTOR = 0.60


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	XBBPHYSICS
//
> XbbPhysics

float CHARM = 1

// maximum run speed in tiles per second
float MAX_SPEED_X = 42 
// acceleration (in seconds, for your convenience ))
float SECONDS_TO_MAX_SPEED = 0.1

// deceleration by friction (ie every frame: speed = speed * FRICTION_X)
float FRICTION_X = 0.8
float AIR_FRICTION_X = 0.975

// modifiers for horizontal movement when in the air
// ie: air_acceleration = ground_acceleration * AIR_ACCELERATION_MODIFIER
float AIR_ACCELERATION_MODIFIER = 0.5//0.35 

// maximum jump height
float JUMP_HEIGHT = 16.5

// extra height added when going through a warp (to land neatly on the platform we walked off of)
float NUDGE_HEIGHT = 1

// during this initial part of the jump, the upward speed is constant.
// the player can cancel the jump during this period.
// increasing this will also make the jump feel "floatier"
float JUMP_CANCEL_TIME = 0.10

// maximum downward vertical speed
float TERMINAL_VELOCITY = 170 //140
// downward acceleration (units/s/s)
float GRAVITY = 200

// if we cancel our jump early, modify the upward momentum (enables tiny jumps that feel very floaty)
float JUMP_CANCEL_MODIFIER = 0.7

// properties of ibb and obb (and ubb)
float WIDTH = 4.8
float IBB_HEIGHT = 6.3
float OBB_HEIGHT = 7.6
float UBB_HEIGHT = 7.0
float IBB_WEIGHT = 1 //0.95
float OBB_WEIGHT = 1
float UBB_WEIGHT = 1

// ubb's scale compared to obb
float UBB_SCALE = 0.90

// starting position (temporary)
float Y_START = 20

// minimum vertical speed when going through a warp (to prevent ibb and obb from getting stuck)
float MIN_WARP_SPEED = 65 //54

// how much of the other player's speed gets added to ours if we jump while standing on top of him
float TEAM_JUMP_FACTOR_Y = 0.4 
float TEAM_JUMP_FACTOR_X = 0.5 

// not really physics but this is how long you're allowed to hold the jump button before actually being able to jump
// ie if ibb is falling down and the player jumps right as ibb hits the ground, he might press the button
// a split second before actually being able to jump. capiche?
float JUMP_BUTTON_WINDOW = 0.05


// FLOW values
float FLOW_MAX_SPEED_X = 100 //60 
float FLOW_JUMP_HEIGHT = 80 //26
float FLOW_TERMINAL_VELOCITY = 250 //170 
float FLOW_GRAVITY = 250 //200
float FLOW_MIN_WARP_SPEED = 80

// the top-of-head bone is not perfectly aligned to the top of the head for obb
// rather than have poor Tom redo the models we'll add a little constant :D
float IBB_TOP_OF_HEAD_OFFSET = 0
float OBB_TOP_OF_HEAD_OFFSET = 0.5
float UBB_TOP_OF_HEAD_OFFSET = 0

// xbbs getting bored!
float BOREDOM_MIN_TIME = 10
float BOREDOM_MAX_TIME = 30


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	INHABITANT (FIN)
//
> Inhabitant 

// after this many seconds without touching the ground, go to numbed state (happens when stuck in a warp for instance)
float AIR_TIME_BEFORE_NUMBED = 1

// how quickly a fin turns brighter when it grows
float BRIGHTNESS_FACTOR = 0.3

// rotation speed when kicked around
float ROLL_SPEED = 1

// how long it takes for the fin to look at the camera when he's idle
float UNFOCUS_TIMER = 0.3

float CHARM = 1

float SIZE = 2.4 //2.1
float MODEL_SCALE = 0.22
float MASS = 0.2 // 0.2 should be a decent weight for a fin. Let's tweak from here.
float RESTITUTION = 0.7 //0.7 // bounciness
float GROUND_FRICTION = 0.97
float AIR_FRICTION = 0.99 // 1.0
// make fins feel floatier by reducing their gravity and terminal velocity
float GRAVITY = 150 //150
float TERMINAL_VELOCITY = 120

// when jumping on top of a fin, if you are directly on top of him he will be squished
// if the distance is smaller than the SQUISH_RATIO
// 0: you are directly on top of him
// 1: you are only barely touching him
float SQUISH_RATIO = 0.3 //0.15
// if he doesn't get squished, launch him with a speed relative to the downward speed of the player
float SQUISH_LAUNCH_SPEED_FACTOR_X = 0.5 //0.5
float SQUISH_LAUNCH_SPEED_FACTOR_Y = 0.35

// ------- similar constants for walkidng a fin into a wall horizontally -------
float VERTICAL_LAUNCH_SPEED_Y = 60
float VERTICAL_LAUNCH_SPEED_X = 10

// to prevent sfx spam, a fin must be "headbutt-free" for at least this many frames before we trigger another (also used for kicking)
int FRAMES_BETWEEN_HEADBUTT = 5

// -------- kicking a fin (walk into him horizontally without a wall blocking the way) ------
// multiply the x speed obtained from regular collision physics (note that fins are treated as having 0 weight vs ibb/obb)
// with this value
float KICK_SPEED_FACTOR = 0.8
// (by default the max speed will be around 60 for running full speed into a fin)
float MAX_KICK_SPEED_X = 40
float MIN_KICK_SPEED_X = 8
// the y speed is a factor of the resulting x speed
float KICK_SPEED_Y = 1.7 //0.9
// also add ibb's upward speed, so if you jump and hit a fin it gets more upward speed
float XBB_JUMP_KICK_FACTOR = 0.6

// -------  headbutting a fin: -------
// minimum y speed to count as a headbutt (otherwise count it as rolling, see next section below this one)
float HEADBUTT_SPEED_THRESHOLD = 20
// if a fin lands on the center of our head, his x speed will be the same as his old x-speed multiplied by this value
float HEADBUTT_X_SPEED_FACTOR = 0.3 //1.0
// the maximum angle a fin can have after a headbutt (0 = straight up, 45 = diagonally)
float HEADBUTT_MAX_ANGLE = 40 //30
// maximum speed after a headbutt (0 = no maximum)
float HEADBUTT_MAX_SPEED = 0
// minimum speed after a headbutt (0 = no minumum)
float HEADBUTT_MIN_SPEED = 0
// headbutt speed factor (when headbutting a fin, multiply the resulting speed by this factor)
float HEADBUTT_SPEED_FACTOR = 0.8 //0.8
// finally, add a little speed if the player himself has a sideways speed, for better control
float HEADBUTT_PLAYER_SPEED_FACTOR = 0.6

// ------ fin rolling off of xbb's head -------
float MAX_ROLL_OFF_SPEED = 12
float MIN_ROLL_OFF_SPEED = 3

// ------ if ibb/obb is standing still, the fins will start pushing him -----
// this is also used as a limit for kicking fins, they will only be kicked if xbb's speed is greater than the threshold
// it is _also_ used to determine if a fin should go numb after colliding with xbb
float PUSH_THRESHOLD = 10

// ----- eating diamonds --------
float GROWTH_PER_DIAMOND = 0.2 // relative to "normal" size
float MAX_SIZE = 1.8 // relative to "normal" size

// ---- shaking (after eating too much, pre-explosion) ----
float SHAKE_DURATION_MIN = 3 // how long the fin shakes before exploding :D
float SHAKE_DURATION_MAX = 4
float SHAKE_INTERVAL = 0.1
float SHAKE_MOVEMENT_X_MIN = 0.4
float SHAKE_MOVEMENT_X_MAX = 0.8
float SHAKE_MOVEMENT_Y_MIN = 0.2
float SHAKE_MOVEMENT_Y_MAX = 0.5
float SHAKE_DELTA_BLINK_TRIGGER = 0.9 // At what point when shaking should we close our eyes? (0.0 - 1.0)

// Fin AI

bool LOVES_IBB = false
bool LOVES_OBB = false
bool LOVES_UBB = true
bool LOVES_FINS = false
bool LOVES_ENEMIES = false
bool LOVES_DIAMONDS = false
bool LOVES_LEVELMEN = false

bool HATES_IBB = false
bool HATES_OBB = false
bool HATES_UBB = false
bool HATES_FINS = false
bool HATES_ENEMIES = false
bool HATES_DIAMONDS = false
bool HATES_LEVELMEN = false

// the attraction graph follows a 1/x curve
// attractors at max range have a force of ATTRACTION_AT_MAX_RANGE, attractors at min range (or less) have a force of 1
float MIN_ATTRACTION_TO_CARE = 0.05 // fins wont move unless total attraction to one direction is greater than this
float ATTRACTION_AT_MAX_RANGE = 0.1
float MIN_ATTRACTION_RANGE = 1
float MAX_ATTRACTION_RANGE = 25 //42

// when randomly hopping about, this is how far a fin will try to hop
float JUMP_DISTANCE = 4    // distance for a single hop
float JUMP_HEIGHT = 5   // height for a single hop
float TIME_BETWEEN_DECISIONS = 2.2 //1.8
float TIME_BETWEEN_DECISIONS_VARATION = 0.4   // 0.2 == time varies between 80% and 120% of TIME_BETWEEN_DECISIONS
float HOP_MIN_DISTANCE = 4  // how far the fin will want to travel (can take multiple hops)
float HOP_MAX_DISTANCE = 12 // how far the fin will want to travel (can take multiple hops)
// a fin will at most hop between HOP_MIN_HOPS and HOP_MAX_HOPS times to reach his target before he gives up
int HOP_MIN_HOPS = 1
int HOP_MAX_HOPS = 5

// when attracted
float FLEE_HOP_HEIGHT = 4.5 //2.5
float FLEE_SPEED = 10 //30
float FLEE_ACCELERATION = 50 //37
// if we're running away from something, decelerate until our speed drops below this value, then go idle
float FLEE_STOP_SPEED = 5 


// when numbed
float NUMB_SPEED_THRESHOLD = 25 // how hard he needs to be hit to go into numbed state
float COOLDOWN_TIME = 1.0 // cooldown starts when fin hits the ground (without bouncing)
float COOLDOWN_TIME_VARIATION = 0.2 // 0.2 == time varies between 80% and 120% of COOLDOWN_TIME
float WAKE_UP_HOP = 2 // how high to jump on wake-up. Use 0 for no jump.

// when fins collide
// if another fin bounces on our head, push him off if his speed is too low
float NUDGE_SPEED_THRESHOLD = 20 
// sideways speed given to top fin
float FIN_COLLISION_X_SPEED = 5 
// bottom fin will jump upward with this speed
float FIN_COLLISION_Y_SPEED = 8 //8 

// size varies between 1 - SIZE_VARIATION and 1 + SIZE_VARIATION
float SIZE_VARIATION = 0.2

// differences in size influence stuff like jump height and width
// 1 + (1/size - 1) * SIZE_FACTOR
// if SIZE_FACTOR > 1, (very) fat fins will be unable to jump entirely, but we'll put a minimum modifier in.
float SIZE_FACTOR = 1
float MINIMUM_SIZE_MODIFIER = 0.1


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	ENEMY
//
> Enemy

float CHARM = 1

float MASS = 0.75

float JUMP_SPEED = 40
float SIZE = 5.2

float SMALL_CRAWLER_MODEL_SCALE = 0.6 //0.57
float LARGE_CRAWLER_MODEL_SCALE = 0.5 //0.57
float HUGE_CRAWLER_MODEL_SCALE = 0.47 //0.57

float SMALL_BOUNCER_MODEL_SCALE = 0.6
float LARGE_BOUNCER_MODEL_SCALE = 0.50

float BOSS_BOUNCER_MODEL_SCALE = 0.11
float BOSS_BOUNCER_SOUL_SCALE = 4

float SMALL_CRAWLER_SOUL_SCALE = 0.50 //0.57
float LARGE_CRAWLER_SOUL_SCALE = 0.95
float HUGE_CRAWLER_SOUL_SCALE = 2.30

float SMALL_BOUNCER_SOUL_SCALE = 0.50
float LARGE_BOUNCER_SOUL_SCALE = 0.95

float CROW_MODEL_SCALE = 0.57
float CROW_SOUL_SCALE = 0.57

float CRAWLER_WIDTH = 5.6
float CRAWLER_DETECTION_WIDTH = 3.3 // how far it looks ahead for the edge of its ledge
float CRAWLER_HEIGHT = 3.7 // apparently not used anymore since circular collision was added
float CRAWLER_ACCELERATION = 100
float CRAWLER_EYES_PAN_DURATION = 0.2

// some models aren't properly pivoted around the bottom (they float ever so slightly above the split, leaving a very tiny gap)
// this compensates but is a hack, it should be fixed in the model itself
float SMALL_CRAWLER_MODEL_OFFSET_Y = 0.05 
float LARGE_CRAWLER_MODEL_OFFSET_Y = 0.05
float HUGE_CRAWLER_MODEL_OFFSET_Y = 0.05

float CROW_SINE_WAVE_FREQUENCY_MAX = 33 //creates a longer or shorter wave (lower being longer)
float CROW_SINE_WAVE_FREQUENCY_MIN = 25 //creates a longer or shorter wave (lower being longer)
float CROW_SINE_WAVE_AMPLITUDE = 3 //changes the height of the wave
float CROW_HORIZONTAL_ACCELERATION = 10
float CROW_HORIZONTAL_DECELERATION = 13
float CROW_VERTICAL_ACCELERATION = 50

// the crow's flapping speed depends on its acceleration
// during it's normal sine movement, the acceleration typically ranges between 300 
// (accelerating downward) and -300 (accelerating upward).
// of course this depends a lot on the constants above.
float CROW_ACCELERATION_FOR_MAXIMUM_FLAP_SPEED = -250
float CROW_ACCELERATION_FOR_MINIMUM_FLAP_SPEED = 100

float CROW_ANIMATION_SPEED_HIGH = 4.5
float CROW_ANIMATION_SPEED_LOW = 0.5

// use values > 1 to use smoothing, around 10 is normal, 24 is pretty high.
// the effect is frame dependent at the moment.
float SOUL_SMOOTHING = 1

int DIAMONDS_SPAWNED_ON_DEATH = 10

// elasticity when colliding with other enemies or vertical walls
float ELASTICITY = 0.8

// minimum jump strength when bouncing off other enemies 
float ELASTICITY_MIN_JUMP_STRENGTH = 40

// in-air acceleration for enemies (only when chasing players)
float AIR_SPEED_ADJUSTMENT = 25

float BIG_BOUNCER_SIZE = 10
int BIG_BOUNCER_DIAMONDS = 10
float BIG_BOUNCER_MASS = 2
float BIG_BOUNCER_ELASTICITY = 0.8

float CUSTOM_BOUNCER_SIZE = 47

float BIG_CRAWLER_WIDTH = 11.2
float BIG_CRAWLER_HEIGHT = 6.0
int BIG_CRAWLER_DIAMONDS = 10
float BIG_CRAWLER_MASS = 2

float HUGE_CRAWLER_WIDTH = 27.5
float HUGE_CRAWLER_HEIGHT = 13.7
int HUGE__DIAMONDS = 10
float HUGE_CRAWLER_MASS = 5

float BOSS_CRAWLER_WIDTH = 47

float DEATH_ANIMATION_TIME = 1.2
float DEATH_SHAKE_AMPLITUDE = 2

float BOSS_MIN_SHAKE_DISTANCE = 60
float BOSS_MAX_SHAKE_DISTANCE = 140
float BOSS_MIN_SHAKE_STRENGTH = 0
float BOSS_MAX_SHAKE_STRENGTH = 1.5

float EYE_BOB_STRENGTH = 0.2
float EYE_BOB_STEP_SIZE = 1.1

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	DIAMOND
//
> Diamond

float CHARM = 1

// special diamonds (diamond rain/diamond core):

float RAIN_MODEL_SCALE = 0.21
int RAIN_NR_DIAMONDS = 10

float CORE_MODEL_SCALE = 0.20 //0.25
float CORE_SIZE = 3.5 //	2.8 //3
float CORE_START_SPEED = 90 // upward speed
float CORE_MIN_ROTATION = 4
float CORE_MAX_ROTATION = 6
float CORE_ROTATIONAL_FRICTION = 0.96


// 90 IS STRAIGHT UP :)
float CORE_SMALL_ANGLE = 90
float CORE_MED_ANGLE_A = 85
float CORE_MED_ANGLE_B = 93
float CORE_LARGE_ANGLE_A = 85
float CORE_LARGE_ANGLE_B = 90
float CORE_LARGE_ANGLE_C = 93

float CORE_SMALL_SPEED = 90
float CORE_MED_SPEED_A = 80
float CORE_MED_SPEED_B = 100
float CORE_LARGE_SPEED_A = 80
float CORE_LARGE_SPEED_B = 100
float CORE_LARGE_SPEED_C = 120


//these tweak the angle of the extra diamonds when a large enemy is killed
float CORE_MIN_ANGLE = 80
float CORE_MAX_ANGLE = 100
float CORE_DIFFERENCE_90  = 10 //this is so that the core won't get too close to each other and overlap

// if a core contains more diamonds than the default enemy diamond count,
// it is scaled accordingly. Use this modifier to change how much effect extra diamonds have.
float CORE_SCALE_FACTOR = 0.5

// this is the range where diamonds start to accelerate towards the players
float ATTRACTION_RANGE_MIN_POWER = 60 //60

// at this range the diamonds have maximum acceleration,
// if the range is even shorter they will just move straight towards the player with instant acceleration
float ATTRACTION_RANGE_FULL_POWER = 16 //2

// maximum acceleration (right before hitting ATTRACTION_RANGE_FULL_POWER)
// the acceleration follows a 1/r^2 curve between ATTRACTION_RANGE_FULL_POWER and ATTRACTION_RANGE_MIN_POWER
float ATTRACTION_ACCELERATION = 150 //200

// the minimum speed used when range is smaller than ATTRACTION_RANGE_FULL_POWER.
// ie: when the players get close to a diamond (<ATTRACTION_RANGE_FULL_POWER), the diamond will just move directly
// towards the player with whatever speed it had, with a minimum of ATTRACTION_MIN_SPEED
float ATTRACTION_MIN_SPEED = 100 //100 //45

// maximum chase speed (on x axis, for the y axis we use terminal velocity)
float MAX_CHASE_SPEED = 500

float SIZE = 3
float MASS = 0.2

float START_SPEED_Y_MIN = 60
float START_SPEED_Y_MAX = 90

float START_SPEED_X_MAX = 25 //25
float START_SPEED_X_MIN = 3	//10
// if we bounce and our speed is greater than the starting max, don't invert it like usual
// but instead reduce it a little
float SPEED_FACTOR_ON_BOUNCE = 0.7

// in PI/second
float MIN_ROTATION_SPEED = 2
float MAX_ROTATION_SPEED = 10 //4

float BOUNCE_FACTOR = 0.8
float MIN_BOUNCE_SPEED_Y = 40
float MAX_BOUNCE_SPEED_Y = 80

// diamonds start with a size of 1
float SIZE_DECREASE_ON_BOUNCE = 0.2 
// scale at full size and lowest size
float START_SCALE = 0.25
float END_SCALE = 0.15

// cheat for final level cuz it too hard
string EXTRA_LIFETIME_LEVEL = "w5_3.txt"
float SIZE_DECREASE_FINAL_LEVEL_FACTOR = 1 // take twice as long to disappear

float ROTATION_SPEED_MAX = 7

// constants for the spin!

float ERUPTION_TIME = 0.15 //0.15 // time to fly out of xbb!
float ERUPTION_TOTAL_TIME = 0.40 //0.35 // time before they drop to the floor
float ERUPTION_TOTAL_TIME_VARIANCE = 0.2 //0.05
float ERUPTION_MIN_SPEED = 10 //10 // angular speed per sec, in radians
float ERUPTION_MAX_SPEED = 3 //3
float ERUPTION_DISTANCE = 8 //7
float ERUPTION_DELAY = 0.01 //0.01

// allowed ease functions: 
// LINEAR, EASEINQUAD, EASEOUTQUAD, EASEINOUTQUAD, EASEINCUBIC, EASEOUTCUBIC, EASEINOUTCUBIC, EASEINQUART, EASEOUTQUART, EASEINOUTQUART, EASEINQUINT, EASEOUTQUINT
// EASEINOUTQUINT, EASEINSINE, EASEOUTSINE, EASEINOUTSINE, EASEINEXPONENTIAL, EASEOUTEXPONENTIAL, EASEINOUTEXPONENTIAL, EASEINCIRCLE, EASEOUTCIRCLE, EASEINOUTCIRCLE
// EASEINELASTIC, EASEOUTELASTIC, EASEINOUTELASTIC, EASEINBACK, EASEOUTBACK, EASEINOUTBACK, EASEINBOUNCE, EASEOUTBOUNCE, EASEINOUTBOUNCE
string ERUPTION_ORIGINATE_FUNCTION = EASEOUTQUART
string ERUPTION_ROTATE_SPEED_FUNCTION = EASEINOUTEXPONENTIAL //EASEOUTSINE //EASEOUTBACK


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	LEVELMAN
//
> LevelMan

float MODEL_SCALE = 0.13
float ACCELERATION = 400
float MIN_CHASE_DISTANCE = 10 // when the levelman is near enough to stop following xbb
float FRICTION = 0.8 // used to slow down when chasing xbb

int FAMILY_SIZE = 8

float JUGGLE_JUMP_HEIGHT = 10 // levelmen jump 10 tiles high when they juggle
float JUGGLE_SPEED_BOOST = 1.5 // the fin will get the same vertical speed as the levelman's jump, multiplied by this

float SECRETMAN_FLOAT_SPEED_MIN = 3
float SECRETMAN_FLOAT_SPEED_MAX = 0.5 //Smaller number is faster
float SECRETMAN_FLOAT_AMPLITUDE = 1

int SWATCH_COLOR_ID_X = 16;
int SWATCH_COLOR_ID_Y = 1;

int SWATCH_SHADOW_ID_X = 7;
int SWATCH_SHADOW_ID_Y = 1;

float LIMBO_DISTANCE_BETWEEN_SCOREBOARDS = 2
float LIMBO_DISPLAY_RANGE = 6.5
float LIMBO_SCOREBOARD_EXTRA_HEIGHT = 10

float LIMBO_SCOREBOARD_FADEIN_TIME = 0.1 //Total time for the scoreboard to fade in to the gradient 
float LIMBO_SCOREBOARD_SCALING_TIME = 0.3 //Total time for the scoreboard to scale down
float LIMBO_SCOREBOARD_FADEIN_TEXT_TIME = 0.04 //Total time for the text to fade in
float LIMBO_SCOREBOARD_FADEOUT_TIME = 0.12 //Total time to fade out the scoreboard
float LIMBO_SCOREBOARD_MOVEMENT_DURATION = 0.5


string LIMBO_SCOREBOARD_IBB_COLOR = "3ca058"
string LIMBO_SCOREBOARD_OBB_COLOR = "a74b66"

string SECRETMEN_DATA_FILE = "secretmen"

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	TOTEM
//
> Totem

float XBB_DANCE_RANGE = 60

string MON_MODEL = "totem_bigbottom.pssg"
string FON_MODEL = "totem_mediummiddle.pssg"
string JON_MODEL = "totem_smalltop.pssg"

float MON_SIZE_X = 5
float MON_SIZE_Y = 18

float FON_SIZE_X = 5
float FON_SIZE_Y = 8

float MASS = 1

// how close the players need to be for the totem to start displaying score
int XRADIUS = 80

float EYES_JON_X_OFFSET = 0
float EYES_JON_Y_OFFSET = 2
float EYES_FON_X_OFFSET = 0
float EYES_FON_Y_OFFSET = 4
float EYES_MON_X_OFFSET = 0
float EYES_MON_Y_OFFSET = -6

float DEPTH = 5

float DIAMOND_TEXTURE_SCALAR = 0.5
float DIAMOND_TEXTURE_OFFSET_X = -4
float DIAMOND_TEXTURE_OFFSET_Y = 0

float SPEECH_OFFSET_X = -20
float SPEECH_OFFSET_Y = -5

float SPEECH_TEXT_OFFSET_X = -21
float SPEECH_TEXT_OFFSET_Y = -6.5

float SCORE_REQUIRED_FOR_LEVEL_2 = 0.40
float SCORE_REQUIRED_FOR_LEVEL_3 = 0.50
float SCORE_REQUIRED_FOR_LEVEL_4 = 0.60
float SCORE_REQUIRED_FOR_LEVEL_5 = 0.70
float SCORE_REQUIRED_FOR_LEVEL_6 = 0.80
float SCORE_REQUIRED_FOR_LEVEL_7 = 0.85
float SCORE_REQUIRED_FOR_LEVEL_8 = 0.90
float SCORE_REQUIRED_FOR_LEVEL_9 = 0.95
float SCORE_REQUIRED_FOR_LEVEL_10 = 1.00

float SPEECH_TEXT_SIZE = 10

bool SPEECH_BUBBLE_DISABLED = true

string FILENAME = "totemsettings"

int XBB_DANCE_3_SCORE = 8
int XBB_DANCE_2_SCORE = 5
int XBB_DANCE_1_SCORE = 1


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	VALVES AND MACHINES
//
> Machine

// scale of the machine models
// note that if machine models are "to scale" with ibb & obb, you can use
// MODEL_SCALE from the > GAME heading here.
// the test machine is a lot smaller so I'll use a higher scale for now - Harald
float MODEL_SCALE = 1.02

float VALVE_PRESSED_TIMER_LENGTH = 0.2
float DEATH_TIMER_LENGTH = 0.75

// how hard to shake the camera when the death timer is running (both valves pressed)
float CAMERA_SHAKE_MIN = 0.2
float CAMERA_SHAKE_MAX = 1.4

// how hard to shake the camera on explosion
float EXPLOSION_CAMERA_SHAKE = 6
float EXPLOSION_CAMERA_SHAKE_TIME = 0.5
float EXPLOSION_CAMERA_SHAKE_ATTENUATION = 0.9

float OVERRIDE_THEME_CROSSFADE_TIME = 2

// construction time per "level"
float CONSTRUCTION_TIME = 0.17

// maximum shake offset while constructing (will quickly diminish)
float CONSTRUCTION_SHAKE_AMPLITUDE = 1.5

// move the valve model slightly down, as it doesn't fit perfectly on the split (this is a hack, should be fixed in the model)
float VALVE_OFFSET_Y = 0.15


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	CAMERA
//
> Camera

// how many tiles are visible (from left to right)
float ZOOM = 240
float INITIAL_ZOOM = 70

// ibb and obb collide with the camera bounds, this buffer is the nr of tiles
// between the edge of the screen and their center.
float BUFFER = 5

// how many tiles ibb and obb are away from the edge of the screen
float EXTRA_SIDE_VIEW = 20
// how far the camera will look ahead
float LOOK_AHEAD_X_UNITS = 12
// how long it takes for the camera to move LOOK_AHEAD_X_UNITS in front of ibb and obb, if they run full-speed
float LOOK_AHEAD_X_TIME = 1
// default camera position (if the level contains no cameras)
float Y_CENTER = 128
// maximum y offset from center
float MAX_Y_OFFSET = 20 //50
// the camera's y offset relative to ibb and obb's distance to the center
float Y_OFFSET_FACTOR = 0.5

// smooth factor (distance reduction per second)
float SMOOTH_FACTOR = 0.94

// how quickly the camera stops shaking (works the same as smooth factor)
float SHAKE_ATTENUATION = 0.88

// When Xbbs die the camera pans back to respawning location over this amount of time
float RESPAWN_PAN_DURATION = 1

// When the xbbs jump on a levelman/secretman the cam zooms in. This value dictates what to zoom in to.
// (A normal zoom value in limbo when the xbbs are on a levelman is ~160)
float TELEPORT_ZOOM = 70

// Camera zooms into the position of the level select bubble's origin, which is at the bottom so we need
// a y offset to focus on where the xbbs stood
float TELEPORT_Y_OFFSET = 8


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	PARTICLE
//
> Particle
 
// Mastar particle size modifier
float MASTER_SIZE = 0.10

//Enemy Respawn
string ENEMY_RESPAWN_TEXTURE = "particletriangle"

// duration of the effect
int ENEMY_RESPAWN_COUNT = 150
float ENEMY_RESPAWN_DURATION = 0.3

// starting position of the particle = DISTANCE +/- (VARIATION * DISTANCE)
float ENEMY_RESPAWN_START_DISTANCE = 10
float ENEMY_RESPAWN_START_DISTANCE_VARIATION = 0.5

string ENEMY_RESPAWN_MOVEMENT_EASE_FUNCTION = "EASEINQUINT"
string ENEMY_RESPAWN_FADE_EASE_FUNCTION = "LINEAR"

// particle size
float ENEMY_RESPAWN_SIZE_SMALL_MIN = 2
float ENEMY_RESPAWN_SIZE_SMALL_MAX = 8
float ENEMY_RESPAWN_SIZE_LARGE_MIN = 2
float ENEMY_RESPAWN_SIZE_LARGE_MAX = 9
float ENEMY_RESPAWN_SIZE_HUGE_MIN = 2
float ENEMY_RESPAWN_SIZE_HUGE_MAX = 10

float ENEMY_RESPAWN_SIZE_VARIATION = 0.5

// rotation speed = SPEED +/- (VARIATION * SPEED)
float ENEMY_RESPAWN_ROTATION_SPEED = 0.3 // rotations per second
float ENEMY_RESPAWN_ROTATION_SPEED_VARIATION = 1

// maximum delay time between particles, relative to total duration
float ENEMY_RESPAWN_MAX_DELAY = 0.4

// size variations (size of the enemy, not the particles it spawns, bit of a confusing name)
// if we use the existing constants they don't work out too nicely so we'll have to tweak them here separately
float ENEMY_RESPAWN_SIZE_LARGE = 1.55
float ENEMY_RESPAWN_SIZE_HUGE = 2.65
float ENEMY_RESPAWN_SIZE_BOSS = 3

bool ENEMY_RESPAWN_SIZE_AFFECTS_NR = true
bool ENEMY_RESPAWN_SIZE_AFFECTS_SCALE = false

//Object death
int OBJECTDEATH_COUNT = 140//120 particle count (will be multiplied with object mass)

//Enemy Move
string ENEMYMOVE_TEXTURE = "particletriangle" //this is the texture that will be used for the particle
int ENEMYMOVE_COUNT = 160
float ENEMYMOVE_MINSIZE = 2
float ENEMYMOVE_MAXSIZE = 8
float ENEMYMOVE_MINVELOCITY = 45.0
float ENEMYMOVE_MAXVELOCITY = 70.0
float ENEMYMOVE_MINLIFETIME = 0.7 //0.7
float ENEMYMOVE_MAXLIFETIME = 1.7 //1.2
float ENEMYMOVE_LIFE_FADEOUT_PERCENTAGE = 50
float ENEMYMOVE_ROTATION_SPEED = 10
float ENEMYMOVE_AIRFRICTION_EFFECT = 0.95
float ENEMYMOVE_GRAVITY_EFFECT = 60

//Enemy Death
string ENEMYDEATH_TEXTURE = "particletriangle" //this is the texture that will be used for the particle
int ENEMYDEATH_COUNT = 160
float ENEMYDEATH_MINSIZE = 2
float ENEMYDEATH_MAXSIZE = 8
float ENEMYDEATH_MINVELOCITY = 45.0
float ENEMYDEATH_MAXVELOCITY = 70.0
float ENEMYDEATH_MINLIFETIME = 0.7//0.7
float ENEMYDEATH_MAXLIFETIME = 1.7//1.2
float ENEMYDEATH_LIFE_FADEOUT_PERCENTAGE = 50
float ENEMYDEATH_ROTATION_SPEED = 10
float ENEMYDEATH_IMPLOSION_EFFECT = 0
float ENEMYDEATH_AIRFRICTION_EFFECT = 0.95
float ENEMYDEATH_GRAVITY_EFFECT = 60
float ENEMYDEATH_SOUL_COUNT = 80

//med enemy particles
string MEDENEMYDEATH_TEXTURE = "particletriangle" //this is the texture that will be used for the particle
int MEDENEMYDEATH_COUNT = 200
float MEDENEMYDEATH_MINSIZE = 2
float MEDENEMYDEATH_MAXSIZE = 9
float MEDENEMYDEATH_MINVELOCITY = 30.0
float MEDENEMYDEATH_MAXVELOCITY = 100.0
float MEDENEMYDEATH_MINLIFETIME = 0.7//0.7
float MEDENEMYDEATH_MAXLIFETIME = 1.7//1.2
float MEDENEMYDEATH_LIFE_FADEOUT_PERCENTAGE = 50
float MEDENEMYDEATH_ROTATION_SPEED = 10
float MEDENEMYDEATH_IMPLOSION_EFFECT = 0
float MEDENEMYDEATH_AIRFRICTION_EFFECT = 0.95
float MEDENEMYDEATH_GRAVITY_EFFECT = 60
float ENEMYDEATH_SOUL_COUNT_MEDIUM = 100

//Big Enemy Death
string BIGENEMYDEATH_TEXTURE = "particletriangle" //this is the texture that will be used for the particle
int BIGENEMYDEATH_COUNT = 240
float BIGENEMYDEATH_MINSIZE = 2
float BIGENEMYDEATH_MAXSIZE = 10
float BIGENEMYDEATH_MINVELOCITY = 20.0
float BIGENEMYDEATH_MAXVELOCITY = 150.0
float BIGENEMYDEATH_MINLIFETIME = 0.5//0.7
float BIGENEMYDEATH_MAXLIFETIME = 2.3//1.2
float BIGENEMYDEATH_LIFE_FADEOUT_PERCENTAGE = 50
float BIGENEMYDEATH_ROTATION_SPEED = 20
float BIGENEMYDEATH_IMPLOSION_EFFECT = 0
float BIGENEMYDEATH_AIRFRICTION_EFFECT = 0.94
float BIGENEMYDEATH_GRAVITY_EFFECT = 60
float ENEMYDEATH_SOUL_COUNT_LARGE = 150

//Boss Enemy Death
string BOSSENEMYDEATH_TEXTURE = "particletriangle" //this is the texture that will be used for the particle
int BOSSENEMYDEATH_COUNT = 240
float BOSSENEMYDEATH_MINSIZE = 2
float BOSSENEMYDEATH_MAXSIZE = 10
float BOSSENEMYDEATH_MINVELOCITY = 20.0
float BOSSENEMYDEATH_MAXVELOCITY = 150.0
float BOSSENEMYDEATH_MINLIFETIME = 0.5//0.7
float BOSSENEMYDEATH_MAXLIFETIME = 2.3//1.2
float BOSSENEMYDEATH_LIFE_FADEOUT_PERCENTAGE = 50
float BOSSENEMYDEATH_ROTATION_SPEED = 20
float BOSSENEMYDEATH_IMPLOSION_EFFECT = 0
float BOSSENEMYDEATH_AIRFRICTION_EFFECT = 0.94
float BOSSENEMYDEATH_GRAVITY_EFFECT = 60
float ENEMYDEATH_SOUL_COUNT_BOSS = 150

//small enemy empty
string ENEMYDEATH_EMPTY_TEXTURE = "particle" //this is the texture that will be used for the particle
int ENEMYDEATH_EMPTY_COUNT = 160
float ENEMYDEATH_EMPTY_MINSIZE = 2
float ENEMYDEATH_EMPTY_MAXSIZE = 8
float ENEMYDEATH_EMPTY_MINVELOCITY = 2
float ENEMYDEATH_EMPTY_MAXVELOCITY = 10
float ENEMYDEATH_EMPTY_MINLIFETIME = 0.7//0.7
float ENEMYDEATH_EMPTY_MAXLIFETIME = 1.7//1.2
float ENEMYDEATH_EMPTY_LIFE_FADEOUT_PERCENTAGE = 50
float ENEMYDEATH_EMPTY_AIRFRICTION_EFFECT = 0.95
float ENEMYDEATH_EMPTY_GRAVITY_EFFECT = 60
float ENEMYDEATH_EMPTY_SINE_MIN_AMPLITUDE = 0.2
float ENEMYDEATH_EMPTY_SINE_MAX_AMPLITUDE = 1.2
float ENEMYDEATH_EMPTY_SINE_MIN_FREQUENCY = 0.1
float ENEMYDEATH_EMPTY_SINE_MAX_FREQUENCY = 1.0
float ENEMYDEATH_EMPTY_SINE_MIN_TIME_SCALAR = 0.5
float ENEMYDEATH_EMPTY_SINE_MAX_TIME_SCALAR = 1.5
float ENEMYDEATH_EMPTY_SMOKE_DENSITY_MIN = 0.01
float ENEMYDEATH_EMPTY_SMOKE_DENSITY_MAX = 0.5

//med enemy particles empty
string MEDENEMYDEATH_EMPTY_TEXTURE = "particle" //this is the texture that will be used for the particle
int MEDENEMYDEATH_EMPTY_COUNT = 200
float MEDENEMYDEATH_EMPTY_MINSIZE = 2
float MEDENEMYDEATH_EMPTY_MAXSIZE = 9
float MEDENEMYDEATH_EMPTY_MINVELOCITY = 2
float MEDENEMYDEATH_EMPTY_MAXVELOCITY = 10
float MEDENEMYDEATH_EMPTY_MINLIFETIME = 0.7//0.7
float MEDENEMYDEATH_EMPTY_MAXLIFETIME = 1.7//1.2
float MEDENEMYDEATH_EMPTY_LIFE_FADEOUT_PERCENTAGE = 50
float MEDENEMYDEATH_EMPTY_AIRFRICTION_EFFECT = 0.95
float MEDENEMYDEATH_EMPTY_GRAVITY_EFFECT = 60
float MEDENEMYDEATH_EMPTY_SINE_MIN_AMPLITUDE = 0.2
float MEDENEMYDEATH_EMPTY_SINE_MAX_AMPLITUDE = 1.2
float MEDENEMYDEATH_EMPTY_SINE_MIN_FREQUENCY = 0.1
float MEDENEMYDEATH_EMPTY_SINE_MAX_FREQUENCY = 1.0
float MEDENEMYDEATH_EMPTY_SINE_MIN_TIME_SCALAR = 0.5
float MEDENEMYDEATH_EMPTY_SINE_MAX_TIME_SCALAR = 1.5
float MEDENEMYDEATH_EMPTY_SMOKE_DENSITY_MIN = 0.01
float MEDENEMYDEATH_EMPTY_SMOKE_DENSITY_MAX = 0.5

//Big Enemy Death Empty
string BIGENEMYDEATH_EMPTY_TEXTURE = "particle" //this is the texture that will be used for the particle
int BIGENEMYDEATH_EMPTY_COUNT = 240
float BIGENEMYDEATH_EMPTY_MINSIZE = 2
float BIGENEMYDEATH_EMPTY_MAXSIZE = 10
float BIGENEMYDEATH_EMPTY_MINVELOCITY = 2
float BIGENEMYDEATH_EMPTY_MAXVELOCITY = 10
float BIGENEMYDEATH_EMPTY_MINLIFETIME = 0.5//0.7
float BIGENEMYDEATH_EMPTY_MAXLIFETIME = 2.3//1.2
float BIGENEMYDEATH_EMPTY_LIFE_FADEOUT_PERCENTAGE = 50
float BIGENEMYDEATH_EMPTY_AIRFRICTION_EFFECT = 0.94
float BIGENEMYDEATH_EMPTY_GRAVITY_EFFECT = 60
float BIGENEMYDEATH_EMPTY_SINE_MIN_AMPLITUDE = 0.2
float BIGENEMYDEATH_EMPTY_SINE_MAX_AMPLITUDE = 1.2
float BIGENEMYDEATH_EMPTY_SINE_MIN_FREQUENCY = 0.1
float BIGENEMYDEATH_EMPTY_SINE_MAX_FREQUENCY = 1.0
float BIGENEMYDEATH_EMPTY_SINE_MIN_TIME_SCALAR = 0.5
float BIGENEMYDEATH_EMPTY_SINE_MAX_TIME_SCALAR = 1.5
float BIGENEMYDEATH_EMPTY_SMOKE_DENSITY_MIN = 0.01
float BIGENEMYDEATH_EMPTY_SMOKE_DENSITY_MAX = 0.5

//Player Death
string PLAYERDEATH_TEXTURE = "particle" //this is the texture that will be used for the particle
int PLAYERDEATH_COUNT = 160
float PLAYERDEATH_MINSIZE = 2
float PLAYERDEATH_MAXSIZE = 6
float PLAYERDEATH_MINVELOCITY = 10.0
float PLAYERDEATH_MAXVELOCITY = 60.0
float PLAYERDEATH_MINLIFETIME = 0.5
float PLAYERDEATH_MAXLIFETIME = 2.0
float PLAYERDEATH_LIFE_FADEOUT_PERCENTAGE = 50
float PLAYERDEATH_ROTATION_SPEED = 0
float PLAYERDEATH_IMPLOSION_EFFECT = 0
float PLAYERDEATH_AIRFRICTION_EFFECT = 0.96
float PLAYERDEATH_GRAVITY_EFFECT = 60
float PLAYERDEATH_COLOR_MULTIPLIER_MIN = 0.0
float PLAYERDEATH_COLOR_MULTIPLIER_MAX = 0.5

//Fin Death
string FINDEATH_TEXTURE = "particle" //this is the texture that will be used for the particle
int FINDEATH_COUNT = 80
float FINDEATH_GRAVITY_EFFECT = 80
float FINDEATH_AIRFRICTION_EFFECT = 0.98
float FINDEATH_IMPLOSION_EFFECT = 0
float FINDEATH_MINLIFETIME = 0.7//0.7
float FINDEATH_MAXLIFETIME = 1.2//1.2
float FINDEATH_ROTATION_SPEED = 10
float FINDEATH_MINVELOCITY = 25.0
float FINDEATH_MAXVELOCITY = 80.0
float FINDEATH_MINSIZE = 3
float FINDEATH_MAXSIZE = 7
float FINDEATH_LIFE_FADEOUT_PERCENTAGE = 70

//Diamond Core Death
string COREDEATH_TEXTURE = "particletriangle" //this is the texture that will be used for the particle
int COREDEATH_COUNT = 30
float COREDEATH_MINSIZE = 2
float COREDEATH_MAXSIZE = 7
float COREDEATH_MINVELOCITY = 5.0
float COREDEATH_MAXVELOCITY = 40.0
float COREDEATH_MINLIFETIME = 0.3
float COREDEATH_MAXLIFETIME = 0.8
float COREDEATH_LIFE_FADEOUT_PERCENTAGE = 50
float COREDEATH_ROTATION_SPEED = 10
float COREDEATH_IMPLOSION_EFFECT = 0
float COREDEATH_AIRFRICTION_EFFECT = 0.98
float COREDEATH_GRAVITY_EFFECT = 60

//Machine Death
string MACHINEDEATH_TEXTURE = "particletriangle"
int MACHINEDEATH_COUNT = 200
float MACHINEDEATH_MINSIZE = 2
float MACHINEDEATH_MAXSIZE = 12
float MACHINEDEATH_MINVELOCITY = 25.0
float MACHINEDEATH_MAXVELOCITY = 60.0
float MACHINEDEATH_MINLIFETIME = 1.0
float MACHINEDEATH_MAXLIFETIME = 3.0
float MACHINEDEATH_LIFE_FADEOUT_PERCENTAGE = 50
float MACHINEDEATH_ROTATION_SPEED = 40
float MACHINEDEATH_IMPLOSION_EFFECT = 0
float MACHINEDEATH_AIRFRICTION_EFFECT = 0.98
float MACHINEDEATH_GRAVITY_EFFECT = 60

//Diamond Bounce
string DIAMONDBOUNCE_TEXTURE = "particletriangle" //this is the texture that will be used for the particle
int DIAMONDBOUNCE_COUNT = 8
float DIAMONDBOUNCE_MINSIZE = 2
float DIAMONDBOUNCE_MAXSIZE = 4
float DIAMONDBOUNCE_MINVELOCITY = 5.0
float DIAMONDBOUNCE_MAXVELOCITY = 20.0
float DIAMONDBOUNCE_MINLIFETIME = 0.3
float DIAMONDBOUNCE_MAXLIFETIME = 0.8
float DIAMONDBOUNCE_LIFE_FADEOUT_PERCENTAGE = 50
float DIAMONDBOUNCE_ROTATION_SPEED = 10
float DIAMONDBOUNCE_IMPLOSION_EFFECT = 0
float DIAMONDBOUNCE_AIRFRICTION_EFFECT = 0.98
float DIAMONDBOUNCE_GRAVITY_EFFECT = 60


//Diamond Death
string DIAMONDDEATH_TEXTURE = "particletriangle" //this is the texture that will be used for the particle
int DIAMONDDEATH_COUNT = 42
float DIAMONDDEATH_MINSIZE = 2
float DIAMONDDEATH_MAXSIZE = 5
float DIAMONDDEATH_MINVELOCITY = 5.0
float DIAMONDDEATH_MAXVELOCITY = 40.0
float DIAMONDDEATH_MINLIFETIME = 0.3
float DIAMONDDEATH_MAXLIFETIME = 0.8
float DIAMONDDEATH_LIFE_FADEOUT_PERCENTAGE = 50
float DIAMONDDEATH_ROTATION_SPEED = 10
float DIAMONDDEATH_IMPLOSION_EFFECT = 0
float DIAMONDDEATH_AIRFRICTION_EFFECT = 0.98
float DIAMONDDEATH_GRAVITY_EFFECT = 60

//Secret Level Diamon Death
string SECRETDIAMOND_DEATH_TEXTURE = "particletriangle" //this is the texture that will be used for the particle
int SECRETDIAMOND_DEATH_COUNT = 240
float SECRETDIAMOND_DEATH_MINSIZE = 2
float SECRETDIAMOND_DEATH_MAXSIZE = 10
float SECRETDIAMOND_DEATH_MINVELOCITY = 20
float SECRETDIAMOND_DEATH_MAXVELOCITY = 150
float SECRETDIAMOND_DEATH_MINLIFETIME = 0.5//0.7
float SECRETDIAMOND_DEATH_MAXLIFETIME = 2.3//1.2
float SECRETDIAMOND_DEATH_LIFE_FADEOUT_PERCENTAGE = 50
float SECRETDIAMOND_DEATH_ROTATION_SPEED = 10
float SECRETDIAMOND_DEATH_IMPLOSION_EFFECT = 0
float SECRETDIAMOND_DEATH_AIRFRICTION_EFFECT = 0.94
float SECRETDIAMOND_DEATH_GRAVITY_EFFECT = 60

int SECRETDIAMOND_DEATH_FIREWORK_ACTIVE_AMOUNT = 3;

//Gravity Bubble Death
string BUBBLEDEATH_TEXTURE = "particle" //this is the texture that will be used for the particle
int BUBBLEDEATH_COUNT = 150
float BUBBLEDEATH_MINSIZE = 2
float BUBBLEDEATH_MAXSIZE = 8
float BUBBLEDEATH_MINVELOCITY = 50
float BUBBLEDEATH_MAXVELOCITY = 60.0
float BUBBLEDEATH_MINLIFETIME = 0.2
float BUBBLEDEATH_MAXLIFETIME = 1.4
float BUBBLEDEATH_LIFE_FADEOUT_PERCENTAGE = 20
float BUBBLEDEATH_ROTATION_SPEED = 10
float BUBBLEDEATH_IMPLOSION_EFFECT = 50
float BUBBLEDEATH_AIRFRICTION_EFFECT = 0.90
float BUBBLEDEATH_GRAVITY_EFFECT = 20

//Tik Tak
string TIKTAK_TEXTURE = "particle" //this is the texture that will be used for the particle
int TIKTAK_PARTICLECOUNT = 50
float TIKTAK_MINSIZE = 1.5
float TIKTAK_MAXSIZE = 4
float TIKTAK_MIN_FORCE_SCALAR = 0.02
float TIKTAK_MAX_FORCE_SCALAR = 0.2
float TIKTAK_MINLIFETIME = 0.4
float TIKTAK_MAXLIFETIME = 1.2
float TIKTAK_LIFETIME_FADEOUT_PERCENTAGE = 50
float TIKTAK_AIRFRICTION_EFFECT = 0.98
float TIKTAK_GRAVITY_EFFECT = 15

float TIKTAK_ATTEMPT_JUMP_FORCE = 50

//Shplutter

//fin shplutter
string FINSHPLUTTER_TEXTURE = "particle" //this is the texture that will be used for the particle
int FINSHPLUTTER_COUNT = 30
float FINSHPLUTTER_MINSIZE = 2
float FINSHPLUTTER_MAXSIZE = 6
float FINSHPLUTTER_MINSPEED = 25.0
float FINSHPLUTTER_MAXSPEED = 45.0
float FINSHPLUTTER_MINLIFETIME = 0.6
float FINSHPLUTTER_MAXLIFETIME = 1.4
float FINSHPLUTTER_LIFETIME_FADEOUT_PERCENTAGE = 50
float FINSHPLUTTER_ANGLE = 35
float FINSHPLUTTER_AIRFRICTION_EFFECT = 0.96
float FINSHPLUTTER_GRAVITY_EFFECT = 60
float FINSHPLUTTER_DELAYINTERVAL = 0 //delay between each particle

//head bump shplutter
string HEADSHPLUTTER_TEXTURE = "particle" //this is the texture that will be used for the particle
float HEADSHPLUTTER_MINSIZE = 1
float HEADSHPLUTTER_MAXSIZE = 3
float HEADSHPLUTTER_MINSPEED = 25.0
float HEADSHPLUTTER_MAXSPEED = 35.0
float HEADSHPLUTTER_MINLIFETIME = 0.4
float HEADSHPLUTTER_MAXLIFETIME = 1.3
float HEADSHPLUTTER_LIFETIME_FADEOUT_PERCENTAGE = 30
float HEADSHPLUTTER_AIRFRICTION_EFFECT = 0.90
float HEADSHPLUTTER_GRAVITY_EFFECT = 20
float HEADSHPLUTTER_PERCENTAGE_RANGE = 50
float HEADSHPLUTTER_FORCE_MIN_TRIGGER = 40
float HEADSHPLUTTER_FORCE_MAX_TRIGGER = 100
int HEADSHPLUTTER_PARTICLE_AMOUNT_MIN = 14
int HEADSHPLUTTER_PARTICLE_AMOUNT_MAX = 30
float HEADSHPLUTTER_ANGLE = 45
float HEADSHPLUTTER_DELAYINTERVAL = 0 //delay between each particle

//hard landing shplutter
string LANDINGSHPLUTTER_TEXTURE = "particle" //this is the texture that will be used for the particle
float LANDINGSHPLUTTER_MINSIZE = 1
float LANDINGSHPLUTTER_MAXSIZE = 3
float LANDINGSHPLUTTER_MINSPEED = 25.0 //25
float LANDINGSHPLUTTER_MAXSPEED = 35.0 //35
float LANDINGSHPLUTTER_MINLIFETIME = 0.4
float LANDINGSHPLUTTER_MAXLIFETIME = 1.3
float LANDINGSHPLUTTER_LIFETIME_FADEOUT_PERCENTAGE = 30
float LANDINGSHPLUTTER_AIRFRICTION_EFFECT = 0.90
float LANDINGSHPLUTTER_GRAVITY_EFFECT = 20
//this percentage is how much of the speed will be added on to the range according to the force
float LANDINGSHPLUTTER_PERCENTAGE_RANGE = 50
float LANDINGSHPLUTTER_LANDING_FORCE_MIN_TRIGGER = 110 //this is the value that the effect will trigger on
float LANDINGSHPLUTTER_LANDING_FORCE_MAX_TRIGGER = 170
float LANDINGSHPLUTTER_ANGLE = 30
float LANDINGSHPLUTTER_DELAYINTERVAL = 0 //delay between each particle
//these values are interpolated between based on the force, so particles generated is between these two figures
int LANDINGSHPLUTTER_PARTICLE_AMOUNT_MIN = 14
int LANDINGSHPLUTTER_PARTICLE_AMOUNT_MAX = 30

//Split warp
string SPLITWARP_TEXTURE = "particle" //this is the texture that will be used for the particle
int SPLITWARP_COUNT = 80 //particle count (will be multiplied with object mass)
float SPLITWARP_MINSIZE = 1 //minimum particle size
float SPLITWARP_MAXSIZE = 6 //maximum particle size
float SPLITWARP_MINVELOCITYMULTIPLIER = 0.02
float SPLITWARP_MAXVELOCITYMULTIPLIER = 0.3
float SPLITWARP_MINLIFETIME = 0.4
float SPLITWARP_MAXLIFETIME = 3
float SPLITWARP_LIFETIME_FADEOUT_PERCENTAGE = 30
float SPLITWARP_AIRFRICTION_EFFECT = 0.97
float SPLITWARP_GRAVITY_EFFECT = 15


//warp tile effect
float WARP_TILE_GRAVITY = 7
float WARP_TILE_AIRFRICTION = 0.98
float WARP_TILE_MINVELOCITY = -2 //-3
float WARP_TILE_MAXVELOCITY = 2 //3
float WARP_TILE_MIN_SIZE = 1
float WARP_TILE_MAX_SIZE = 6
float WARP_TILE_WIDTH_PARTICLE_SCALAR = 10
//these vars all affect the sine wave pattern of the particles
float WARP_TILE_SINE_WAVE_FREQUENCY = 0.8 //0.5 //creates a longer or shorter wave (lower being longer)
float WARP_TILE_SINE_WAVE_AMPLITUDE = 1.2 //changes the height of the wave
float WARP_TILE_SINE_WAVE_TIME_SCALAR = 1 //1 //changes the speed at which the wave transforms
float WARP_TILE_SCPLUTTER_SIZE = 0.5 //half the size of the original tik tak particle effect

float WARP_TILE_STATIC_PARTICLES = 30

//ibb warp tile effect
float IBB_WARP_TILE_GRAVITY = 7
float IBB_WARP_TILE_AIRFRICTION = 0.98
float IBB_WARP_TILE_MINVELOCITY = -3
float IBB_WARP_TILE_MAXVELOCITY = 3
float IBB_WARP_TILE_MIN_SIZE = 1
float IBB_WARP_TILE_MAX_SIZE = 6
float IBB_WARP_TILE_WIDTH_PARTICLE_SCALAR = 14
//these vars all affect the sine wave pattern of the particles
float IBB_WARP_TILE_SINE_WAVE_FREQUENCY = 0.7 //0.5 //creates a longer or shorter wave (lower being longer)
float IBB_WARP_TILE_SINE_WAVE_AMPLITUDE = 1.2 //1 //changes the height of the wave
float IBB_WARP_TILE_SINE_WAVE_TIME_SCALAR = 1.0 //0.010 //changes the speed at which the wave transforms

//obb warp tile effect
float OBB_WARP_TILE_GRAVITY = 7
float OBB_WARP_TILE_AIRFRICTION = 0.98
float OBB_WARP_TILE_MINVELOCITY = -3
float OBB_WARP_TILE_MAXVELOCITY = 3
float OBB_WARP_TILE_MIN_SIZE = 1
float OBB_WARP_TILE_MAX_SIZE = 6
float OBB_WARP_TILE_WIDTH_PARTICLE_SCALAR = 14
//these vars all affect the sine wave pattern of the particles
float OBB_WARP_TILE_SINE_WAVE_FREQUENCY = 0.3 //0.5 //creates a longer or shorter wave (lower being longer)
float OBB_WARP_TILE_SINE_WAVE_AMPLITUDE = 1.2 //1 //changes the height of the wave
float OBB_WARP_TILE_SINE_WAVE_TIME_SCALAR = 1.0 //0.010 //changes the speed at which the wave transforms

//Soul effect - what does this one do?
float SOUL_MIN_LIFETIME = 0.1
float SOUL_MAX_LIFETIME = 0.5
float SOUL_MIN_VELOCITY = -0.5
float SOUL_MAX_VELOCITY = 0.5
float SOUL_MIN_SIZE = 1
float SOUL_MAX_SIZE = 6
float SOUL_GRAVITY_EFFECT = 10
float SOUL_AIRFRICTION_EFFECT = 0.98
int SOUL_COUNT = 50
float SOUL_LIFETIME_FADEOUT_PERCENTAGE = 40
float SOUL_LIFETIME_FADEIN_PERCENTAGE = 80
float SOUL_REAPPEARANCE_TIME = 2
string SOUL_TEXTURE_NAME = "particle"


// region effect
float REGION_MIN_LIFETIME = 2 // lifetimeMin
float REGION_MAX_LIFETIME = 8 // lifetimeMax
float REGION_MIN_VELOCITY = -6 // speedMin
float REGION_MAX_VELOCITY = -1 // speedmax
float REGION_MIN_SIZE = 3 //sizeMin
float REGION_MAX_SIZE = 6 //sizeMax
float REGION_GRAVITY_EFFECT = 1 //gravityEffect
float REGION_AIRFRICTION_EFFECT = 0.98 //airFriction
float REGION_DENSITY = 0.1 //density
float REGION_LIFETIME_FADEOUT_PERCENTAGE = 50 //fadeOutPercent
float REGION_FADEIN_PERCENTAGE = 90 //fadeInPercent
float REGION_FREQUENCY_REAPPEARENCE_MIN = 1 //reappearanceMin
float REGION_FREQUENCY_REAPPEARENCE_MAX = 6 //reappearanceMax
float REGION_MIN_DEPTH = 1 // depthMin
float REGION_MAX_DEPTH = 2 // depthMax
float REGION_PARRALAX_ZOOM_EFFECT = 0.5
string REGION_TEXTURE_NAME = "particle"
float REGION_AIR_FRICTION_MIN = 0.97
float REGION_AIR_FRICTION_MAX = 0.99


//Smoke effect

float SMOKE_MIN_LIFETIME = 2
float SMOKE_MAX_LIFETIME = 10.0
float SMOKE_MIN_SIZE = 2
float SMOKE_MAX_SIZE = 12
float SMOKE_MIN_VELOCITY = 0 //1
float SMOKE_MAX_VELOCITY = 6
float SMOKE_MIN_ANGLE = 45
float SMOKE_MAX_ANGLE = 135 
float SMOKE_GRAVITY_EFFECT = -2
float SMOKE_AIRFRICTION_EFFECT = 0.98
string SMOKE_TEXTURE = "particle"
int SMOKE_MAX_PARTICLES = 100
float SMOKE_LIFETIME_FADEOUT_PERCENTAGE = 50
float SMOKE_DENSITY_MIN = 0.01
float SMOKE_DENSITY_MAX = 0.5
int SMOKE_MIN_DEPTH = 0
int SMOKE_MAX_DEPTH = 4
float SMOKE_PARTICLE_SPAWN_RANGE = 5 //spread out the particles over a range
float SMOKE_SINE_MIN_AMPLITUDE = 0.2
float SMOKE_SINE_MAX_AMPLITUDE = 1.2
float SMOKE_SINE_MIN_FREQUENCY = 0.1
float SMOKE_SINE_MAX_FREQUENCY = 1.0
float SMOKE_SINE_MIN_TIME_SCALAR = 0.5
float SMOKE_SINE_MAX_TIME_SCALAR = 1.5

//in Tiled on Machines you can change these params to effect smoke
//producesSmoke
//smokeEmitterOffsetX
//smokeParticleAmount
//smokeParticleSpawnRange






/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	PATHS
//
> Paths

string MENUS = "menus"
string FONTS = "fonts"
string SCRIPTS = "scripts"
string ANIMATION_DATA = "animations"
string LEVELMEN_SETTINGS = "levelmen"
string TOTEM_SETTINGS = "totem"

string RESOURCES = "content"

string MODELS = "models"
string TEXTURES = "textures"

string LEVELS = "Levels"

string AUDIO_WIN = "audio/fmodpc"
string AUDIO_PS3 = "audio/fmodps3"

string SHADERS = "shaders"

string DECORATIONSETS = "DecorationSets"

string LOCALIZATION = "Localization"

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	SHADER
//
> Shader

int PALETTE_COLUMN = 2
int SWATCH_UP_1 = 4
int SWATCH_UP_2 = 5
int SWATCH_UP_3 = 6
int SWATCH_DOWN_1 = 1
int SWATCH_DOWN_2 = 2
int SWATCH_DOWN_3 = 3

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	DECORATION
//
> Decoration

float MODEL_SCALE = 1.8 //5

string LIMBO_PALETTE = "w0_limbo_01"

float DEFAULT_FAR_NEAR_DEPTH = 1.6

int DEFAULT_SWATCH1_FAR_UP_ROW = 2
int DEFAULT_SWATCH1_FAR_DOWN_ROW = 5
int DEFAULT_SWATCH1_FAR_COLUMN = 2

int DEFAULT_SWATCH1_NEAR_UP_ROW = 1
int DEFAULT_SWATCH1_NEAR_DOWN_ROW = 7
int DEFAULT_SWATCH1_NEAR_COLUMN = 3

int DEFAULT_SWATCH2_COLUMN = 3
int DEFAULT_SWATCH2_UP_ROW = 6
int DEFAULT_SWATCH2_DOWN_ROW = 12

// Percentage, 1.0 is full, 0.0 goes back to static
float PARALLAX_ZOOM_EFFECT = 0.7 //1.0

// objects at this distance or farther will start color shifting first
// should be > 1 (the depth of objects at the front layer)
float COLOR_SHIFT_MAX_DEPTH = 2.5

bool PARALLAX_ENABLED = true

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	MUSIC
//
> Music

int NR_OF_CHANNELS = 7

string DEFAULT_WAVEBANK = "music.xwb"

string MENU_MUSIC = "w1l1"

string TOTEM_TRACK_NAME = "totem" //note: I will be appending numbers to this in code so if they all have a name followed by a number in FMOD that would be great :)
float TOTEM_MUSIC_RANGE = 150
float TOTEM_MUSIC_BPM = 150

string DEFAULT_SOUNDBANK = "music.xsb"

float SECRET_DIAMOND_FADE_DURATION = 2.5 //seconds

string UBB_MUSIC = "w4l2alt"
float UBB_MUSIC_FADE_DURATION = 0.5

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	SFX
//
> SFX

float PLAY_RANGE = 400 //the range at which the sounds will play in relation to the camera

// name of the parameter that controls sounds keying off/fading out
string PARAMETER_KEY_OFF = "keyoff"

string XBB_WALK = "xbb_walk"
string XBB_LAND = "xbb_land"
string XBB_FALLING = "xbb_flight"
string XBB_DEATH = "xbb_death"
string XBB_BUMP_HEAD = "xbb_bump_head"
string XBB_BUMP_SIDE = "xbb_bump_side"
string XBB_JUMP_UP = "xbb_jump_up"
string XBB_JUMP_DOWN = "xbb_jump_down"
string XBB_JUMP_ASSISTED_SLOW = "xbb_assisted_a"
string XBB_JUMP_ASSISTED_FAST = "xbb_assisted_b"
string XBB_JUMP_RUNNING = "xbb_run_jump"

string WARP_UP = "warp_pass"
string WARP_DOWN = "warp_pass"

string ENEMY_CRAWL = "enemy_crawl"
string ENEMY_BOUNCE = "enemy_bounce"
string ENEMY_DEATH = "enemy_death"
string ENEMY_DEATH_EMPTY = "enemy_empty"
string SOUL_POP = "soul_pop"

string TIKTAK_LAND = "tktk_lnd_empty"
string TIKTAK_USE = "tktk_lnd_use"
string TIKTAK_JUMP = "tktk_jmp_fail"

string DIAMOND_BOUNCE = "dmnd_bounce"
string DIAMOND_COLLECT = "dmnd_collect"
string DIAMOND_CORE_BOUNCE = "dmnd_cr_break"
string DIAMOND_CORE_COLLECT = "dmnd_cr_col"
string DIAMOND_RAIN = "dmnd_rain"

string FIN_BOUNCE = "fin_bounce"
string FIN_DEATH = "fin_shplutter"

string LEVELMAN_WALK = "levelman_walk" // not used .tk
string LEVELMAN_LAND = "levelman_land"

string BUBBLE_POP = "bbble_pop"
string POWERUP = "powerup_on"

string MACHINE_IMPACT = "machine_impact"
string MACHINE_EXPLOSION = "mach_explode"

string MODIFIER = "force"
string 3DMODIFIER = "position_x"
string XBB_DEATH_MODIFIER = "life_death"

string MENU_MOVE_SELECTION = "menu_move"
string MENU_SELECTION = "menu_select"


string DEMO_FLASH = "demo_flash" // when white flashes happen between scenes in the demo

string LEVEL_REVEAL = "level_reveal" // (when xbb stands on a level teleport man and the circle appears) *
string LEVEL_ENTER = "level_enter" // (when xbb joins xbb on a teleport and a level is entered) *
string ENEMY_EMPTY = "enemy_empty" // (when enemy is killed, but his diamond was already released) *
string VOID = "void" // (when anything passes through a void, force shold work the same as with warps--min max settings in the constants file are also handy here) *
string UBB_CROWNED = "ubb_crowned" // (when ubb settles down with the fins and ends his journey) *
string SECRET_GET = "secret_get" // (when xbb collects a large secret level diamond) *
string MACH_SW_ON = "mach_sw_on" // (when player presses down a machine switch) *
string MACH_SW_OFF = "mach_sw_off" // (when player moves off a pressed switch, causing it to move up again) *

string MACH_AMBIENT = "machine_vox" //(sustained sound created by a working machine. Plays for as long as a machine is active (should use position_x). Force parame modulates character of voice. Big machines should have more force.)
string MACH_ONE_VALVE_PRESSED = "mach_rmbl" //(When both players stand on the switches, this sound starts, and ends when machine explodes, or when either player steps off a switch) *
string MACH_TWO_VALVES_PRESSED = "mach_cdwn"

string AUTO_POP = "auto_pop" // (If xbb die, and an enemy pops without being directly killed, this sound plays) *
string MACH_BUILD = "mach_build" // (when machine 'grows' layer by layer, this triggers once per layer. Vary weight parameter to get different sounds) *
string SCORE_RVL = "score_rvl" // (score reveal, happens at the end of a level, when the diamond appears showing xbb's scores) *
string BRD_SQWK = "brd_sqwk" // (when bird sees player beneath him) *
string BRD_IMPCT = "brd_impct" // (bird impact, when bird hits the ground after swooping) *
string BRD_FLAP = "brd_flap" // (whenever the bird wings flap, triggers fired from bird animation?) ****************** NO SOUND?!?! *************************
string PLAYER_JOIN = "ply_join" // (when a new player joins the player select menu) ****************** NO SOUND?!?! *************************
string SCOREMAN_TRANSFORM = "score_man" // (when the scoreman changes to gold or platinum)
string LIMBO_SCOREBOARD = "limbo_scr" // (when the scoreboard in limbo appears) ****************** NO SOUND?!?! *************************
string BRD_SUSTAIN = "brd_sustain" // (one instance of this sound is sustained for each bird enemy that's around. Sound is stopped when the bird dies)

// Defined sound events for machine animations
// manim_recoil
// manim_impact
// manim_lidflap

// Defined sound events for level men animations
// lv_left_footfall  
// lv_right_footfall 

float XBB_WALK_MIN = 0
float XBB_WALK_MAX = 42
float XBB_FALL_SPEED_MIN = 50
float XBB_FALL_SPEED_MAX = 170
float XBB_LAND_SPEED_MIN = 5
float XBB_LAND_SPEED_MAX = 170
float WARP_FORCE_MIN = 55 // minimum force at which the warp sound will be triggered
float WARP_FORCE_MAX = 170
float BUBBLE_RADIUS_MIN = 0
float BUBBLE_RADIUS_MAX = 50
float ENEMY_BOUNCE_FORCE_MIN = 20 
float ENEMY_BOUNCE_FORCE_MAX = 100
float TIKTAK_EMPTY_FORCE_MIN = 50
float TIKTAK_EMPTY_FORCE_MAX = 100
float TIKTAK_USE_FORCE_MIN = 50
float TIKTAK_USE_FORCE_MAX = 100
float FIN_BOUNCE_FORCE_MIN = 25
float FIN_BOUNCE_FORCE_MAX = 85
float FIN_DEATH_SIZE_MIN = 0 // was 0
float FIN_DEATH_SIZE_MAX = 40
float LEVELMAN_WALK_FORCE_MIN = 50
float LEVELMAN_WALK_FORCE_MAX = 170
float LEVELMAN_LAND_SPEED_MIN = 50
float LEVELMAN_LAND_SPEED_MAX = 170
float VOID_SPEED_MIN = 55
float VOID_SPEED_MAX = 170




/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	PALETTES
//
> Palettes

// transparant pixel
int COORDINATE_TRANSPARANT_X = 1
int COORDINATE_TRANSPARANT_Y = 16

// general stuff
int COORDINATE_GENERAL_EYES_X = 7
int COORDINATE_GENERAL_EYES_Y_LIGHT = 2
int COORDINATE_GENERAL_EYES_Y_DARK = 3

int COORDINATE_GENERAL_SHADE_X = 7
int COORDINATE_GENERAL_SHADE_Y = 1

// decoration
int COORDINATE_DECORATION_X = 3

//xbb
int COORDINATE_IBB_X = 10
int COORDINATE_OBB_X = 11
int COORDINATE_UBB_X = 8

int COORDINATE_XBB_Y = 1
int COORDINATE_XBB_SHADOW_Y = 2
int COORDINATE_XBB_EYES_Y = 2

//fins
int COORDINATE_FIN_X = 9
int COORDINATE_FIN_Y = 1
int COORDINATE_FIN_EYES_X = 9
int COORDINATE_FIN_EYES_Y = 2

//enemies
int COORDINATE_ENEMIES_X = 12
int COORDINATE_ENEMIES_Y = 1
int COORDINATE_ENEMY_SOUL_X = 12
int COORDINATE_ENEMY_SOUL_Y = 2
int COORDINATE_ENEMY_EYES_X = 12
int COORDINATE_ENEMY_EYES_Y = 2

//levelmen
int COORDINATE_LEVELMAN_EYES_X = 7
int COORDINATE_LEVELMAN_EYES_Y = 2

//eyes in the dark (used to make the eyes if fins and levelmen light up in the cave)
int COORDINATE_EYES_IN_THE_DARK_X = 7
int COORDINATE_EYES_IN_THE_DARK_Y = 3

//split
int COORDINATE_SPLIT_X = 1
int COORDINATE_SPLIT_Y = 1

//warpgate (normal gate) palette color position
int COORDINATE_WARPGATE_X = 4
int COORDINATE_WARPGATE_Y = 1

//obb gate
int COORDINATE_OBBGATE_X = 11
int COORDINATE_OBBGATE_Y = 1

//ibb gate
int COORDINATE_IBBGATE_X = 10
int COORDINATE_IBBGATE_Y = 1

//tiktak
int COORDINATE_TIKTAK_X = 4
int COORDINATE_TIKTAK_Y = 3

//powerup
int COORDINATE_POWERUP_X_1 = 6
int COORDINATE_POWERUP_Y_1 = 1
int COORDINATE_POWERUP_X_2 = 6
int COORDINATE_POWERUP_Y_2 = 2

//speech bubble color
int COORDINATE_SPEECH_X = 4
int COORDINATE_SPEECH_Y = 1
string HEX_SPEECH_TEXT = "000000" //Hex color code

//totem
int COORDINATE_TOTEM_JON_X = 14
int COORDINATE_TOTEM_JON_Y = 1
int COORDINATE_TOTEM_FON_X = 14
int COORDINATE_TOTEM_FON_Y = 2
int COORDINATE_TOTEM_MON_X = 14
int COORDINATE_TOTEM_MON_Y = 3

int COORDINATE_TOTEM_SHADER_X = 7
int COORDINATE_TOTEM_SHADER_Y = 1

int COORDINATE_TOTEM_EYES_X = 7
int COORDINATE_TOTEM_EYES_Y = 2

//region particles
int COORDINATE_REGION_PARTICLE = 23

//pause menu
string HEX_MENU_TEXT = "FFFFFF" //Hex color Code

//controllers in player select menu
int COORDINATE_CONTROLLER_X = 23
int COORDINATE_CONTROLLER_Y_LIGHT = 1
int COORDINATE_CONTROLLER_Y_DARK = 2

int COORDINATE_CONTROLLER_INACTIVE_Y_LIGHT = 3
int COORDINATE_CONTROLLER_INACTIVE_Y_DARK = 4

string default = "color-base"

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	EYES
//
> Eyes

// to start looking at a dude he needs to be INTEREST_RANGE units closer than whatever we're looking at now
float INTEREST_RANGE = 10

// if something is closer than this, don't look at it
float MINIMUM_DISTANCE = 5 //10

// default eye settings

float XBB_WIDTH = 0.6
float XBB_HEIGHT = 0.7
float XBB_STANCE_OFFSET_X = 0
float XBB_STANCE_OFFSET_Y = 0
float XBB_STANCE_WIDTH = 1.3 //1.3

// offset when looking at a target
float XBB_STANCE_OFFSET_FOCUSED = 0

// use -1 for none
float XBB_ANOMALY_LEFT_WIDTH = -1
float XBB_ANOMALY_LEFT_HEIGHT = -1
float XBB_ANOMALY_RIGHT_WIDTH = -1
float XBB_ANOMALY_RIGHT_HEIGHT = -1

// use 0 for none
float XBB_ANOMALY_LEFT_OFFSET_X = 0
float XBB_ANOMALY_LEFT_OFFSET_Y = 0
float XBB_ANOMALY_RIGHT_OFFSET_X = 0
float XBB_ANOMALY_RIGHT_OFFSET_Y = 0

float IBB_WIDTH = 0.6
float IBB_HEIGHT = 0.7
float IBB_STANCE_OFFSET_X = 0 //0
float IBB_STANCE_OFFSET_Y = 0.2
float IBB_STANCE_WIDTH = 1.4 //1.3

// offset when looking at a target
float IBB_STANCE_OFFSET_FOCUSED = 0

// use -1 for none
float IBB_ANOMALY_LEFT_WIDTH = -1
float IBB_ANOMALY_LEFT_HEIGHT = -1
float IBB_ANOMALY_RIGHT_WIDTH = -1
float IBB_ANOMALY_RIGHT_HEIGHT = -1

// use 0 for none
float IBB_ANOMALY_LEFT_OFFSET_X = 0
float IBB_ANOMALY_LEFT_OFFSET_Y = 0
float IBB_ANOMALY_RIGHT_OFFSET_X = 0
float IBB_ANOMALY_RIGHT_OFFSET_Y = 0

float OBB_WIDTH = 0.6
float OBB_HEIGHT = 0.7
float OBB_STANCE_OFFSET_X = 0 //0
float OBB_STANCE_OFFSET_Y = -0.8
float OBB_STANCE_WIDTH = 1.1 //1.3

// offset when looking at a target
float OBB_STANCE_OFFSET_FOCUSED = 0

// use -1 for none
float OBB_ANOMALY_LEFT_WIDTH = -1
float OBB_ANOMALY_LEFT_HEIGHT = -1
float OBB_ANOMALY_RIGHT_WIDTH = -1
float OBB_ANOMALY_RIGHT_HEIGHT = -1

// use 0 for none
float OBB_ANOMALY_LEFT_OFFSET_X = 0
float OBB_ANOMALY_LEFT_OFFSET_Y = 0
float OBB_ANOMALY_RIGHT_OFFSET_X = 0
float OBB_ANOMALY_RIGHT_OFFSET_Y = 0

float UBB_WIDTH = 0.6
float UBB_HEIGHT = 0.7
float UBB_STANCE_OFFSET_X = 0
float UBB_STANCE_OFFSET_Y = -0.2
float UBB_STANCE_WIDTH = 1.55

// offset when looking at a target
float UBB_STANCE_OFFSET_FOCUSED = 0

// use -1 for none
float UBB_ANOMALY_LEFT_WIDTH = -1
float UBB_ANOMALY_LEFT_HEIGHT = -1
float UBB_ANOMALY_RIGHT_WIDTH = -1
float UBB_ANOMALY_RIGHT_HEIGHT = -1

// use 0 for none
float UBB_ANOMALY_LEFT_OFFSET_X = 0
float UBB_ANOMALY_LEFT_OFFSET_Y = 0
float UBB_ANOMALY_RIGHT_OFFSET_X = 0
float UBB_ANOMALY_RIGHT_OFFSET_Y = 0

// angle in terms of PI (3,1415926)
// note: these are coupled to the looking up/down animation.
// there is a separate variable to clamp the max downward angle.
float XBB_MAX_UP_ANGLE = 0.25 //0.178
float XBB_MAX_DOWN_ANGLE =  0.25 // 0.178

// stop looking down at this position in the downward-look animation (0 <= XBB_DOWN_ANGLE_CLAMP <= 1)
float XBB_DOWN_ANGLE_CLAMP = 0.5

// ----

float FIN_WIDTH = 0.4
float FIN_HEIGHT = 0.3
float FIN_STANCE_OFFSET_X = 0.6
float FIN_STANCE_OFFSET_Y = 0
float FIN_STANCE_WIDTH = 0.7

// offset when looking at a target
float FIN_STANCE_OFFSET_FOCUSED = 0

// use -1 for none
float FIN_ANOMALY_LEFT_WIDTH = -1
float FIN_ANOMALY_LEFT_HEIGHT = -1
float FIN_ANOMALY_RIGHT_WIDTH = -1
float FIN_ANOMALY_RIGHT_HEIGHT = -1

// use 0 for none
float FIN_ANOMALY_LEFT_OFFSET_X = 0
float FIN_ANOMALY_LEFT_OFFSET_Y = 0
float FIN_ANOMALY_RIGHT_OFFSET_X = 0
float FIN_ANOMALY_RIGHT_OFFSET_Y = 0

// angle in terms of PI (3,1415926)
float FIN_MAX_UP_ANGLE = 0.2
float FIN_MAX_DOWN_ANGLE = 0.2

// ----

float BOUNCER_WIDTH = 0.6
float BOUNCER_HEIGHT = 0.7
float BOUNCER_STANCE_OFFSET_X = 0
float BOUNCER_STANCE_OFFSET_Y = 0
float BOUNCER_STANCE_WIDTH = 1.3 //1

// offset when looking at a target
float BOUNCER_STANCE_OFFSET_FOCUSED = 1.7

// use -1 for none
float BOUNCER_ANOMALY_LEFT_WIDTH = -1
float BOUNCER_ANOMALY_LEFT_HEIGHT = -1
float BOUNCER_ANOMALY_RIGHT_WIDTH = -1
float BOUNCER_ANOMALY_RIGHT_HEIGHT = -1

// use 0 for none
float BOUNCER_ANOMALY_LEFT_OFFSET_X = 0
float BOUNCER_ANOMALY_LEFT_OFFSET_Y = 0
float BOUNCER_ANOMALY_RIGHT_OFFSET_X = 0
float BOUNCER_ANOMALY_RIGHT_OFFSET_Y = 0

// angle in terms of PI (3,1415926)
float BOUNCER_MAX_UP_ANGLE = 0.2
float BOUNCER_MAX_DOWN_ANGLE = 0.1

// ----

float BIG_BOUNCER_WIDTH = 0.9
float BIG_BOUNCER_HEIGHT = 1.05
float BIG_BOUNCER_STANCE_OFFSET_X = 0
float BIG_BOUNCER_STANCE_OFFSET_Y = 0
float BIG_BOUNCER_STANCE_WIDTH = 1.5 //1

// offset when looking at a target
float BIG_BOUNCER_STANCE_OFFSET_FOCUSED = 1.7

// use -1 for none
float BIG_BOUNCER_ANOMALY_LEFT_WIDTH = -1
float BIG_BOUNCER_ANOMALY_LEFT_HEIGHT = -1
float BIG_BOUNCER_ANOMALY_RIGHT_WIDTH = -1
float BIG_BOUNCER_ANOMALY_RIGHT_HEIGHT = -1

// use 0 for none
float BIG_BOUNCER_ANOMALY_LEFT_OFFSET_X = 0
float BIG_BOUNCER_ANOMALY_LEFT_OFFSET_Y = 0
float BIG_BOUNCER_ANOMALY_RIGHT_OFFSET_X = 0
float BIG_BOUNCER_ANOMALY_RIGHT_OFFSET_Y = 0

// angle in terms of PI (3,1415926)
float BIG_BOUNCER_MAX_UP_ANGLE = 0.2
float BIG_BOUNCER_MAX_DOWN_ANGLE = 0.1

// ----

float CRAWLER_WIDTH = 0.5 //0.6
float CRAWLER_HEIGHT = 0.6 //0.7
float CRAWLER_STANCE_OFFSET_X = 1.2 //1.7
float CRAWLER_STANCE_OFFSET_Y = -1.05
float CRAWLER_STANCE_WIDTH = 0.9 //1

// offset when looking at a target
float CRAWLER_STANCE_OFFSET_FOCUSED = 0

// use -1 for none
float CRAWLER_ANOMALY_LEFT_WIDTH = -1
float CRAWLER_ANOMALY_LEFT_HEIGHT = -1
float CRAWLER_ANOMALY_RIGHT_WIDTH = -1
float CRAWLER_ANOMALY_RIGHT_HEIGHT = -1

// use 0 for none
float CRAWLER_ANOMALY_LEFT_OFFSET_X = 0
float CRAWLER_ANOMALY_LEFT_OFFSET_Y = 0
float CRAWLER_ANOMALY_RIGHT_OFFSET_X = 0
float CRAWLER_ANOMALY_RIGHT_OFFSET_Y = 0

// angle in terms of PI (3,1415926)
float CRAWLER_MAX_UP_ANGLE = 0.0 //0.2
float CRAWLER_MAX_DOWN_ANGLE = 0.0

// ----

float BIG_CRAWLER_WIDTH = 0.75 //0.6
float BIG_CRAWLER_HEIGHT = 0.9 //0.7
float BIG_CRAWLER_STANCE_OFFSET_X = 1.7 //1.7
float BIG_CRAWLER_STANCE_OFFSET_Y = -1.5
float BIG_CRAWLER_STANCE_WIDTH = 2.0 //1

// offset when looking at a target
float BIG_CRAWLER_STANCE_OFFSET_FOCUSED = 0

// use -1 for none
float BIG_CRAWLER_ANOMALY_LEFT_WIDTH = -1
float BIG_CRAWLER_ANOMALY_LEFT_HEIGHT = -1
float BIG_CRAWLER_ANOMALY_RIGHT_WIDTH = -1
float BIG_CRAWLER_ANOMALY_RIGHT_HEIGHT = -1

// use 0 for none
float BIG_CRAWLER_ANOMALY_LEFT_OFFSET_X = 0
float BIG_CRAWLER_ANOMALY_LEFT_OFFSET_Y = 0
float BIG_CRAWLER_ANOMALY_RIGHT_OFFSET_X = 0
float BIG_CRAWLER_ANOMALY_RIGHT_OFFSET_Y = 0

// angle in terms of PI (3,1415926)
float BIG_CRAWLER_MAX_UP_ANGLE = 0.0 //0.2
float BIG_CRAWLER_MAX_DOWN_ANGLE = 0.0

// ----

float HUGE_CRAWLER_WIDTH = 1.5 //0.6
float HUGE_CRAWLER_HEIGHT = 1.9 //0.7
float HUGE_CRAWLER_STANCE_OFFSET_X = 3.2 //1.7
float HUGE_CRAWLER_STANCE_OFFSET_Y = -4
float HUGE_CRAWLER_STANCE_WIDTH = 3.0 //1

// offset when looking at a target
float HUGE_CRAWLER_STANCE_OFFSET_FOCUSED = 0

// use -1 for none
float HUGE_CRAWLER_ANOMALY_LEFT_WIDTH = -1
float HUGE_CRAWLER_ANOMALY_LEFT_HEIGHT = -1
float HUGE_CRAWLER_ANOMALY_RIGHT_WIDTH = -1
float HUGE_CRAWLER_ANOMALY_RIGHT_HEIGHT = -1

// use 0 for none
float HUGE_CRAWLER_ANOMALY_LEFT_OFFSET_X = 0
float HUGE_CRAWLER_ANOMALY_LEFT_OFFSET_Y = 0
float HUGE_CRAWLER_ANOMALY_RIGHT_OFFSET_X = 0
float HUGE_CRAWLER_ANOMALY_RIGHT_OFFSET_Y = 0

// angle in terms of PI (3,1415926)
float HUGE_CRAWLER_MAX_UP_ANGLE = 0.0 //0.2
float HUGE_CRAWLER_MAX_DOWN_ANGLE = 0.0

// ---

float BLINK_DURATION = 0.1
float BLINK_FREQ_UPPER_BOUND = 8
float BLINK_FREQ_LOWER_BOUND = 3

float BLINK_VERTICAL_SPEED_THRESHOLD = 90 //speed in y direction
float BLINK_PLAYER_INPUT_THRESHOLD_FALLING = 0.1 //seconds
float BLINK_PLAYER_INPUT_THRESHOLD_BLINK_ROUTINE = 3.0 //seconds
float BLINK_TRACKING_THRESHOLD = 50 //game units of distance

float BLINK_DOUBLEBLINK_CHANCE = 10 //percentage
float BLINK_DOUBLEBLINK_PAUSE = 0.1

float BLINK_ENEMY_RESPAWN_DURATION = 0.2

// length of the blink for each circumstance (seconds)
float BLINK_HAS_BURDEN_WHILE_LIFTING_DURATION = 0.3
float BLINK_HAS_BEEN_LANDED_UPON_DURATION = 0.15
float BLINK_HAS_BUMPED_HEAD_DURATION = 0.15
float BLINK_HAS_HEADED_FIN_DURATION = 0.1
float BLINK_HAS_LANDED_HARD_DURATION = 0.3
float BLINK_HAS_LAUNCHED_FROM_TIKTAK_DURATION = 0.2

// fins
float BLINK_FIN_BUMPED_DURATION = 0.15

//levelmen
float BLINK_LEVELMAN_BOUNCED_FIN_DURATION = 0.2

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	CAVE
//
> Cave

float FADE_DURATION = 1.0 //seconds

// as an optimization: the cave shaders are only loaded in this level, so it only works there
string LEVEL = "42"

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	VIBRATION
//
> Vibration

float BOSS_BOUNCE_TIME = 0.2
float BOSS_BOUNCE_SM_INTENSITY = 0
float BOSS_BOUNCE_LM_INTENSITY = 50

float LANDED_HARD_SM_INTENSITY = 0     // 0 - 1
float LANDED_HARD_LM_INTENSITY = 0.7   // 0 - 1
float LANDED_HARD_FADEIN_DURATION = 0  // seconds
float LANDED_HARD_FADEOUT_DURATION = 0
float LANDED_HARD_FULL_DURATION = 0.3

float HIT_FIN_FADEIN_DURATION = 0      // seconds
float HIT_FIN_FADEOUT_DURATION = 0
float HIT_FIN_FULL_DURATION = 0.2
//Running into a fin is approx 42 (force), while headbutting one directly up is about 100, so gauge the 
//normaliser constants on that. Normalising with 0 and 120 means running into a fin (42) is 
//0.35 (42 / 140) vibration (just above the threshold for a slight vibration)...
float HIT_FIN_NORM_MIN = 0
float HIT_FIN_NORM_MAX = 120           //<<<< In case that doesn't make sense, basically lower this value to make the vibrations stronger...
float HIT_FIN_SM_MULTIPLIER = 0
float HIT_FIN_LM_MULTIPLIER = 1        //<<<< Or use this multiplier...

float DEATH_SM_INTENSITY = 0
float DEATH_LM_INTENSITY = 1
float DEATH_FADEIN_DURATION = 0
float DEATH_FADEOUT_DURATION = 0
float DEATH_FULL_DURATION = 0.4

float WAITING_DEATH_SM_INTENSITY = 0
float WAITING_DEATH_LM_INTENSITY = 1
//Waiting for death uses a different constant (GAME_TIME_TO_DEATH) to decide the duration of the fade-in

float TIKTAK_SM_MULTIPLIER = 0         // This is a multiplier (tiktakForce * TIKTAK_MULTIPLIER)
float TIKTAK_LM_MULTIPLIER = 1         // This is a multiplier
float TIKTAK_FADEIN_DURATION = 0       // seconds
float TIKTAK_FADEOUT_DURATION = 0
float TIKTAK_FULL_DURATION = 0.3
//When normalising the force of a launch when on a tiktak we use these 2 constants. A normal xbb jump onto a tiktak
//is roughly 64, while a xbb jumping off another jumping xbb, which is jumping off a raised platform onto a tiktak is about 160-180!
//You can combine these normalisation constants and the multipliers to get the desired vibration effect...
//(Remember that vibrations can only be felt slightly at about 0.35, so if min = 0, max needs to be about 180 for 
//a small vibration to occur when doing a normal xbb jump (64 / 180 = 0.355))
float TIKTAK_NORM_MIN = 0
float TIKTAK_NORM_MAX = 180            //<<<< Lower this value to make the vibrations stronger

float TIKTAK_JUMP_ATTEMPT_SM_INTENSITY = 0
float TIKTAK_JUMP_ATTEMPT_LM_INTENSITY = 0.5
float TIKTAK_JUMP_ATTEMPT_FADEIN_DURATION = 0
float TIKTAK_JUMP_ATTEMPT_FADEOUT_DURATION = 0
float TIKTAK_JUMP_ATTEMPT_FULL_DURATION = 0.2

float DIAMOND_RAIN_SM_INTENSITY = 0
float DIAMOND_RAIN_LM_INTENSITY = 0.8
float DIAMOND_RAIN_FADEIN_DURATION = 0
float DIAMOND_RAIN_FADEOUT_DURATION = 3
float DIAMOND_RAIN_FULL_DURATION = 0.1

float SECRET_DIAMOND_SM_INTENSITY = 1
float SECRET_DIAMOND_LM_INTENSITY = 1
float SECRET_DIAMOND_FADEIN_DURATION = 0
float SECRET_DIAMOND_FADEOUT_DURATION = 0
float SECRET_DIAMOND_FULL_DURATION = 0.5

float LERP_MIN = 0.35
float LERP_MAX = 0.8

float MAX_DISTANCE = 150
float MIN_DISTANCE = 10

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	REPLAYS
//
> Replays

// if we want this session to record to the REPLAY_FILENAME
bool RECORD = false
// if we want to replay the REPLAY_FILENAME
bool REPLAY = false
string REPLAY_FILENAME = "attract.replay"

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	DRAW_ORDERS
//
> Draw_Order

int FILL_REGIONS = 0
int BACKGROUND = 1
int WARP_TILES = 2
int DECO_MASKS = 3
int DEFAULT = 4
int CAVE_OVERLAY = 5
int DECORATION = 6
int DECORATION_BUBBLE_START = 7
// note: a bunch of "layers" are added here, they will be used to speed up the bubbles in limbo
// ie: each bubble uses its own layer for its background and only the layers that are currently in an opened bubble are drawn
int DECORATION_BUBBLE_END = 27
int PARTICLES = 28
int EYES = 29

int COUNT = 30

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	Z_DEPTHS
//
> Z_Depths

// higher == closer to camera

// start position of any decoration that's not in the front pane (currently LEVELMEN_FRONT - 5 * LEVELMEN_DISTANCE_PER_LAYER - "a little extra")
float DECORATION_START = -40

// the closest levelman (distance == 1 in the editor) will be at this z depth
float LEVELMEN_FRONT = -8

// for each additional layer, the levelmen move this many units backwards
// so a levelman with distance == N has a z value of LEVELMEN_FRONT - (N-1) * LEVELMEN_DISTANCE_PER_LAYER
// note: it's weird, even though eyes are 3 units in front of levelmen, if their distance is less than 6 the eyes still overlap..
float LEVELMEN_DISTANCE_PER_LAYER = 4

// note that eyes are drawn 2.5 units in front of the model they belong to.
// except levelmen cuz they're fat

float FIN = 0
float ENEMY = 0
float DIAMOND = 0

int SMOKE_PARTICLES = 3

float XBB = 2.7

float PARTICLES = 8

float FRONT_DECORATION = 10

float SPLIT = 11

float WARP_GRADIENT_TILES = -41

float GRAVITY_LEAKS = -39 // just in front of deco


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	GRAVITY_LEAKS
//
> Gravity_leaks

// size of bounding box and radius of the model (if scale == 1)
// change these only if the art asset changes
float RADIUS = 13 // radius of the model when full-scale (used for the inverse gravity effect)

// bounding box, change to modify the size of the leak in-game
float BB_START_RADIUS = 1
// most of the following can be overridden in the editor
float BB_FINAL_RADIUS = 13 // editor property: "size"

float SPAWN_INTERVAL = 4 // editor property: "interval"
float GROW_TIME = 1 // editor property: "growtime"

// allowed ease functions: 
// LINEAR, EASEINQUAD, EASEOUTQUAD, EASEINOUTQUAD, EASEINCUBIC, EASEOUTCUBIC, EASEINOUTCUBIC, EASEINQUART, EASEOUTQUART, EASEINOUTQUART, EASEINQUINT, EASEOUTQUINT
// EASEINOUTQUINT, EASEINSINE, EASEOUTSINE, EASEINOUTSINE, EASEINEXPONENTIAL, EASEOUTEXPONENTIAL, EASEINOUTEXPONENTIAL, EASEINCIRCLE, EASEOUTCIRCLE, EASEINOUTCIRCLE
// EASEINELASTIC, EASEOUTELASTIC, EASEINOUTELASTIC, EASEINBACK, EASEOUTBACK, EASEINOUTBACK, EASEINBOUNCE, EASEOUTBOUNCE, EASEINOUTBOUNCE
string GROW_FUNCTION = EASEOUTQUINT 

float VERTICAL_ACCELERATION = 0 // editor property: "accelerationy"
float VERTICAL_MAX_SPEED = 0 // editor property: "speedy"

float HORIZONTAL_ACCELERATION = 0 // editor property: "accelerationx"
float HORIZONTAL_MAX_SPEED = 0 // editor property: "speedx"

bool COLLISION_ENABLED = false //editor property: "collision"

// how long it takes for the bubble to pop when an xbb has left it
float POP_TIMER = 0.02
// should the pop timer restart if an xbb enters the bubble again?
bool RESTART_TIMER_ON_REENTRY = false

// gravity inside a bubble is lower than normal
float GRAVITY_MODIFIER = 0.6

// starting wobble values (so they dont go completely in sync)
float WOBBLE_OFFSET_X = 1.55 // about 1/2 pi
float WOBBLE_OFFSET_Y = 0

// scale of the bubble varies between 1 - WOBBLE_AMPLITUDE and 1 + WOBBLE_AMPLITUDE
float WOBBLE_AMPLITUDE_X = 0.025
float WOBBLE_AMPLITUDE_Y = 0.025

// number of wobbles per second :)
float WOBBLE_FREQUENCY_X = 0.1627273864
float WOBBLE_FREQUENCY_Y = 0.16

// a rotation makes the wobble effect seem more random (rotations per second)
float ROTATION_FREQUENCY = 0.1
// how quickly rotation changes direction (nr of seconds to change direction)
float ROTATION_ACCELERATION = 0.16
// how often direction changes
float ROTATION_DIRECTION_CHANGE_FREQUENCY = 0.05
// plus a random factor (0 = always at the same time, 1 = between 0 seconds and t*2 seconds)
float ROTATION_DIRECTION_CHANGE_RANDOMNESS = 0.5

// ripple effect (not the same as wobble! ;))
float RIPPLE_AMPLITUDE_UNOCCUPIED = 0.01
float RIPPLE_AMPLITUDE_OCCUPIED = 0.04
// how quickly the amplitude change when the bubble goes from unoccupied to occupied
float RIPPLE_AMPLITUDE_CHANGE_SPEED = 0.1

// how long a ripple lasts
// NOTE: when changing this value, also change BUBBLE_RIPPLE_DURATION in shaderconstants.cginc!!
float RIPPLE_DURATION = 9

// when the last ripple is RIPPLE_OVERLAP_TIME % done, a new one will start
// (they can also start earlier, to add some randomness, but never later)
float RIPPLE_OVERLAP_TIME = 0.5

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	SECRET DIAMOND CORE
//
> Powerup

string DEFAULT_COLOR_THEME = cheat
float SIZE = 9
float THEME_SWITCH_TIME = 0.1
float MODEL_SCALE = 0.3 

float ROTATION_SPEED_MIN = 0.4 //in PI/seconds
float ROTATION_SPEED_MAX = 10.0
float ROTATE_DISTANCE_MIN = 6
float ROTATE_DISTANCE_MAX = 60

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	SHARED LIGHT
//
> Shared_Light

// speed to fluctuate at (1x means about 3.14 seconds for full fluctuation)
// if the players are close to eachother
float FLUCTUATION_SPEED_CLOSE_IBB = 1
float FLUCTUATION_SPEED_CLOSE_OBB = 1
float DISTANCE_CLOSE = 7

// speed to fluctuate at (4x means about 0.8 seconds for full fluctuation)
// if the players are far away from eachother
float FLUCTUATION_SPEED_FAR_IBB = 3
float FLUCTUATION_SPEED_FAR_OBB = 2
float DISTANCE_FAR = 45



/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	SCORES
//
> Scores

int 1 = 300
string 1_TXT = "You don't like shiny things?"


int 2 = 500
string 2_TXT = "Pretty good."

int 3 = 650
string 3_TXT = "It takes two to tango."

int 4 = 800
string 4_TXT = "True team spirit."

int 5 = 900
string 5_TXT = "Two minds act as one."

// if the player scored more than 5
string 6_TXT = "One of you is a robot."

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	REWARDS
//
> Rewards

bool DISABLED = false //Disable all trophy related features - unlocking, registering contexts etc.

int HEADED_FIN_COUNT = 10
int WARP_COUNT = 6

// PS3 trophy Id for each reward. Use -1 as a placeholder, this is the same number used by sony.
// GRADE: Title (Description)
int FULL_ZEN_ID = 0    // GOLD:   Full Zen              (Finish all levels with Zen)
int PARTY_ID = 1    // SILVER: Party                 (Finish all regular levels, make it to the partai!)
int ALL_CRYSTALS_ID = 2    // SILVER: All Crystals          (Collect all secret level cores)
int COLLECTION_COMPLETE_ID = 3    // SILVER: Collection Complete   (Unlock all levelmen && secretmen)
int BRAIN_DAMAGE_ID = 4    // SILVER: Brain Damage          (Make it to party in Brainsplit (single-player) mode)
int FIRST_CRYSTAL_ID = 5    // BRONZE: First Crystal         (Collect your first secret Crystal)
int SMALL_ZEN_ID = 6    // BRONZE: Small Zen             (Get highest score in one level)
int KING_UBB_ID = 7    // H-BRONZE: King Ubb            (Guide Ubb to Lost Fin City)
int QUALITY_TIME_ID = 8    // H-BRONZE: Quality Time        (Bounce fin about 10 times - don't touch split, levelmen or warps!)
int FALLCROBATICS_ID = 9    // H-BRONZE: Fallcrobatics       (Pass through 6 different warps without landing)
int MINT_CONDITION_ID = 10  // H-BRONZE: Mint Condition      (Complete a level without dying)


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	MENU
//
> Menu

// how much to pad the menu options' bounding boxes (so they are easier to select)
// relative to the height.
float MOUSE_HOVER_SIZE_BUFFER = 0.4

float CLOUD_SPEED_MAX = 0.1
float CLOUD_SPEED_MIN = 0.01

string ICONS_FONT_FILE = "ps3_controller_icons"
int ICONS_FONT_CHARACTER_SIZE = 128

float KEY_REPEAT_START = 0.3
float KEY_REPEAT_CONTINUOUS = 0.15
float KEY_REPEAT_CREDITS = 0.08

string PALETTE = "menu"

// character select menu

// color of the bubble.
string BUBBLE_COLOR = "758389"

float BUBBLE_SCALE_OPAQUE = 0.8
float BUBBLE_SCALE_TRANSPARANT = 1

float BUBBLE_GROW_SPEED = 25

// when the bubble grows to this scale, ibb and obb start falling down
float BUBBLE_XBB_FALL_SCALE = 2

string PROFILE_SELECT_TEXT_COLOR = "AAAAAA"
string PROFILE_SELECT_TEXT_COLOR_SELECTED = "FFFFFF"

// Controller 1
int CONTROLLER1_UNSELECTED_COLOR1_X = 23
int CONTROLLER1_UNSELECTED_COLOR1_Y = 1
int CONTROLLER1_UNSELECTED_COLOR2_X = 23
int CONTROLLER1_UNSELECTED_COLOR2_Y = 2
int CONTROLLER1_SELECTED_COLOR1_X = 24
int CONTROLLER1_SELECTED_COLOR1_Y = 1
int CONTROLLER1_SELECTED_COLOR2_X = 24
int CONTROLLER1_SELECTED_COLOR2_Y = 2
int CONTROLLER1_DISCONNECTED_COLOR1_X = 23
int CONTROLLER1_DISCONNECTED_COLOR1_Y = 1
int CONTROLLER1_DISCONNECTED_COLOR2_X = 23
int CONTROLLER1_DISCONNECTED_COLOR2_Y = 2

// Controller 2
int CONTROLLER2_UNSELECTED_COLOR1_X = 23
int CONTROLLER2_UNSELECTED_COLOR1_Y = 1
int CONTROLLER2_UNSELECTED_COLOR2_X = 23
int CONTROLLER2_UNSELECTED_COLOR2_Y = 2
int CONTROLLER2_SELECTED_COLOR1_X = 24
int CONTROLLER2_SELECTED_COLOR1_Y = 3
int CONTROLLER2_SELECTED_COLOR2_X = 24
int CONTROLLER2_SELECTED_COLOR2_Y = 4
int CONTROLLER2_DISCONNECTED_COLOR1_X = 23
int CONTROLLER2_DISCONNECTED_COLOR1_Y = 1
int CONTROLLER2_DISCONNECTED_COLOR2_X = 23
int CONTROLLER2_DISCONNECTED_COLOR2_Y = 2

// how long to wait when both players have selected their characters before starting the intro sequence
float START_DELAY = 0.3

// leaderboard stuffs
string LEADERBOARD_INCOMPLETE_LEVELMAN_COLOR = "DEE1E2"

string LEADERBOARD_GOLD_LEVELMAN_COLOR = "FFE70F"
string LEADERBOARD_PLATINUM_LEVELMAN_COLOR = "BAFFEB"

int LEADERBOARD_NR_OF_ENTRIES_ON_SCREEN = 6
int LEADERBOARD_NR_OF_INITIAL_ENTRIES = 15

// defaults!

// when the player selection menu is entered, how smoothly ibb and obb change floating position
float DEFAULTS_DUDE_FLOAT_SMOOTH_FACTOR = 0.99
float DEFAULTS_DUDE_FLOAT_ROTATION_MIN = 0.8
float DEFAULTS_DUDE_FLOAT_ROTATION_MAX = 0.8
float DEFAULTS_DUDE_FLOAT_OFFSET_MIN = -0.1
float DEFAULTS_DUDE_FLOAT_OFFSET_MAX = 0.1
float DEFAULTS_DUDE_FLOAT_TIMER = 4.5

float DEFAULTS_IBB_BUBBLE_X = -0.7
float DEFAULTS_IBB_BUBBLE_Y = -0.6
float DEFAULTS_OBB_BUBBLE_X = 0.7
float DEFAULTS_OBB_BUBBLE_Y = -0.6

string DEFAULTS_FONT = "nationalsemibold"
string DEFAULTS_TEXT = "lorem ipsum"

// 0 = left/top, 1 = center, 2 = right/bottom
int DEFAULTS_HALIGN = 1
int DEFAULTS_VALIGN = 1

float DEFAULTS_X = 0
float DEFAULTS_Y = 0

// height of the font, compared to total screen height (which is 2)
float DEFAULTS_ITEMHEIGHT = 0.1

// horizontal distance between letters
float DEFAULTS_SPACING = 0 // Gets overridden by menus

// vertical distance between letters
float DEFAULTS_LEADING = 0

float DEFAULTS_COLOR_R = 0
float DEFAULTS_COLOR_G = 0
float DEFAULTS_COLOR_B = 0

float DEFAULTS_HIGHLIGHT_R = 1
float DEFAULTS_HIGHLIGHT_G = 0
float DEFAULTS_HIGHLIGHT_B = 0

float PAUSE_NODE_HEIGHT = 0.015
float PAUSE_NODE_WIDTH = 0.015
float PAUSE_SLIDER_SPEED = 1.0


// z values!

// first layer to draw: the hidden background (in play menu)
float Z_HIDDEN_BACKGROUND_FILL = -10  // black quad
float Z_HIDDEN_TREES = -9.9 // position of first tree
float Z_INCREASE_PER_TREE = 0.1 // position increase per tree (so that they appear in order of declaration in the menu's xml file)
float Z_MENU_BUBBLE = -1 // position of the bubbles that will punch a hole in the white background

// second layer
float Z_BACKGROUND = -1 // z position of the white background

// note: other stuff will be created with z = 0 by default

float CREDITS_MANUAL_SCROLL_UP_SPEED = 0.8 // seems not to work
float CREDITS_MANUAL_SCROLL_DOWN_SPEED = 0.8 // seems not to work
string CREDIT_HIGHLIGHT_COLOR = d22d61
string CREDIT_NORMAL_COLOR = 000000
float CREDIT_LOWER_FADE_BOUND = 0.30 //0.7
float CREDIT_UPPER_FADE_BOUND = 0.60 //0.9
float CREDIT_FADE_DURATION = 0.2
float CREDIT_SPACING = 0.07
int CREDIT_VISIBLE_ENTRIES = 5

float LEADERBOARD_LOWER_FADE_BOUND = 0.35
float LEADERBOARD_UPPER_FADE_BOUND = 0.65

float PAUSE_WIDGET_DEADZONE = 0.5
float WIDGET_SFX_INTERVAL = 0.1

float LIST_SLIDE_TIME = 0.1 //0.5

string DEMO_DISABLED_COLOR = "AAAAAA"


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	MISCELLANEOUS STUFF
//
> Misc

float WARP_SCROLL_TIME = 6
float WARP_WAVE_TIME = 4.12

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	PLAYGROUND
//
> Playground

float TEXT_SCALE = 0.1
float TEXT_X = 133
float TEXT_Y = 94
string TEXT_COLOR = "FFFFFF"

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//  PLAYER_POINTER
//
> Player_Pointer

string TEXTURE = "scoreboard_icon_secret_found"

string COLOR_IBB = "3ca058"
string COLOR_OBB = "a74b66"
string COLOR_UBB = "D9C840"

float MIN_DISTANCE = 0
float MAX_DISTANCE = 70
float SCALE_CLOSE = 0.008
float SCALE_FAR = 0.02

bool SHOW_UBB_WHEN_INACTIVE = false

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	LEVEL
//
> Level

float CHECKPOINT_DISTANCE_BETWEEN_PLAYERS = 10


//Clouds
float CLOUDS_ACCELERATION = 0.03

string SECRETMAN_SAVE_FILE = "secretmansave.sav"

int REGION_PADDING_TOP = 10000
int REGION_PADDING_BOTTOM = 10000
int REGION_PADDING_LEFT = 0
int REGION_PADDING_RIGHT = 0

// if anything goes WORLD_BORDER tiles outside of the level, it will get killed
// because there's probably something going terribly wrong and it's falling off of the world anyway :)
int WORLD_BORDER = 50

// time it takes to fade out the screen when you're teleporting with a levelman/secretman
float FADE_TIME = 1

// first tileset: collision tiles (ie split and such)
string TILESET_LEVEL = "leveltiles" 
int SPLIT_GID = 2
int OBBGATE_GID = 3
int IBBGATE_GID = 4
int GATE_GID = 5
int CONSTRUCTION_GID = 7 // added a tile that helps me measure things in tiled. It's invisible in the game (RB)
int TIKTAK_GID = 9 
int FAKE_SPLIT_GID = 10

// second tileset: objects, includes camera and audio objects, start and save positions, bonus objects
string TILESET_OBJECTS = "objects"
int DIAMOND_GID = 1
int POWERUP_GID = 2
int CAMERA_GID = 9
int COLOR_SHIFT_GID = 10
int COMBINED_START = 17
int IBB_START = 18
int OBB_START = 19
int SAVE_POINT_GID = 20
int AUDIO_MUSIC_GID = 25 // new, will control music mix
int AUDIO_SOUND_GID = 26 // new, will control ambient sounds
int LEAK_GID = 33
int GRAVITY_MODIFIER_DOWN_GID = 41
int GRAVITY_MODIFIER_UP_GID = 42

// third tileset: cast, includes enemies and fins
string TILESET_CAST = "cast"
int FIN_GID = 1
int BOUNCER_GID = 9
int CRAWLER_GID = 10
int BIG_BOUNCER_GID = 11
int BIG_CRAWLER_GID = 12
int HUGE_CRAWLER_GID = 13
int CROW_GID = 14
int TOTEM_GID = 17
int UBB_GID = 25

// fourth tileset: secretmen
string TILESET_SECRETMEN = "secretmen"
int SECRETMAN_01_GID = 1
int SECRETMAN_02_GID = 2
int SECRETMAN_03_GID = 3
int SECRETMAN_04_GID = 4
int SECRETMAN_05_GID = 5
int SECRETMAN_06_GID = 6
int SECRETMAN_07_GID = 7
int SECRETMAN_08_GID = 8

// fifth tileset: levelmen
string TILESET_LEVELMEN = "levelmen"
int LEVELMEN_FAMILY_1_MAN_1_GID = 1
int LEVELMEN_FAMILY_1_MAN_2_GID = 2

// tileset: machines
string TILESET_MACHINES = "machines"
int MACHINE_PART_01_GID = 1
int MACHINE_PART_02_GID = 2
int MACHINE_PART_03_GID = 3
int MACHINE_PART_04_GID = 4
int MACHINE_PART_05_GID = 5
int MACHINE_PART_06_GID = 6
int MACHINE_PART_07_GID = 7
int MACHINE_PART_08_GID = 8
int MACHINE_PART_09_GID = 9
int MACHINE_PART_10_GID = 10
int MACHINE_PART_11_GID = 11
int MACHINE_PART_12_GID = 12
int MACHINE_PART_13_GID = 13
int MACHINE_PART_14_GID = 14
int MACHINE_PART_15_GID = 15
int MACHINE_PART_16_GID = 16
int MACHINE_VALVE_GID = 17


// etc.

// decoration. individual GIDs are generated automatically
// each name should correspond to a .txt file in content/DecorationSets
// which contains the names of all the models in the decoration tileset.
string TILESET_BACKGROUND_1 = "deco palms"  
string TILESET_BACKGROUND_2 = "deco ampellen" 
string TILESET_BACKGROUND_3 = "deco straight bushes" 
string TILESET_BACKGROUND_4 = "deco retro hills" 
string TILESET_BACKGROUND_5 = "deco tricoli" 
string TILESET_BACKGROUND_6 = "deco gum bushes" 
string TILESET_BACKGROUND_7 = "deco boogie trees" 
string TILESET_BACKGROUND_8 = "deco sandwalkers" 
string TILESET_BACKGROUND_9 = "deco fish clouds" 
string TILESET_BACKGROUND_10 = "deco houses" 
string TILESET_BACKGROUND_11 = "deco houses centre" 
string TILESET_BACKGROUND_12 = "deco flats" 
string TILESET_BACKGROUND_13 = "deco statues" 
string TILESET_BACKGROUND_14 = "deco ambassadors"
string TILESET_BACKGROUND_15 = "deco lazy drops"
string TILESET_BACKGROUND_16 = "deco ubergines"
string TILESET_BACKGROUND_17 = "deco boabab" 
string TILESET_BACKGROUND_18 = "deco grand hills" 
string TILESET_BACKGROUND_19 = "deco floebers" 
string TILESET_BACKGROUND_20 = "deco citrus clouds"
string TILESET_BACKGROUND_21 = "deco spikes"
string TILESET_BACKGROUND_22 = "objects" //this may need to be sorted out eventually and given a better name
string TILESET_BACKGROUND_23 = "deco parapanta"
string TILESET_BACKGROUND_24 = "deco broken flats"
string TILESET_BACKGROUND_25 = "deco liners"
string TILESET_BACKGROUND_26 = "deco billboards"
string TILESET_BACKGROUND_27 = "deco neutelings"
string TILESET_BACKGROUND_28 = "deco riedijk"
string TILESET_BACKGROUND_29 = "deco record clouds"
string TILESET_BACKGROUND_30 = "deco shards"
string TILESET_BACKGROUND_31 = "deco shards down"
string TILESET_BACKGROUND_32 = "deco sigrid"
string TILESET_BACKGROUND_33 = "deco speckleglobes"
string TILESET_BACKGROUND_34 = "deco joost"
string TILESET_BACKGROUND_35 = "deco richard"
string TILESET_BACKGROUND_36 = "deco limbo"
string TILESET_BACKGROUND_37 = "deco flints"
string TILESET_BACKGROUND_38 = "deco flow"
string TILESET_BACKGROUND_39 = "deco bumphills"
string TILESET_BACKGROUND_40 = "deco spineleafs"
string TILESET_BACKGROUND_41 = "deco wobbleclouds"
string TILESET_BACKGROUND_42 = "deco bibbob"
string TILESET_BACKGROUND_43 = "deco patterns"
string TILESET_BACKGROUND_44 = "deco masks"
string TILESET_BACKGROUND_45 = "placeholder"
string TILESET_BACKGROUND_46 = "placeholder"
string TILESET_BACKGROUND_47 = "placeholder"
string TILESET_BACKGROUND_48 = "placeholder"
string TILESET_BACKGROUND_49 = "placeholder"
string TILESET_BACKGROUND_50 = "placeholder"

string MASTER_LIST = "level_list"
string LIMBO = "Chunks/w0_limbo"
string PLAYGROUND = "Chunks/w0_playground.tmx"
string DEMO = "demo.txt"

// LOAD LEVEL AT START

//string LEVEL = "Chunks/w0_limbo.tmx"
//string LEVEL = "test.txt"
//string LEVEL = "all.txt"
//string LEVEL = "all2.txt"
//string LEVEL = "world_work.txt"
//string LEVEL = "igf.txt"
//string LEVEL = "levelmen_size_test.txt"
//string LEVEL = "demo.txt"
//string LEVEL = "short demo.txt"

//string LEVEL = "world1.txt"
//string LEVEL = "world2.txt"
//string LEVEL = "world3.txt"
//string LEVEL = "world4.txt"
//string LEVEL = "world5.txt"

//string LEVEL = "music_shift_test.txt"


//string LEVEL = "goatse.txt"

//string LEVEL = "party_full.txt" //Complete sequence (no debug)
//string LEVEL = "party_full_end.txt" //Quick intro, full reminisce (no debug)
//string LEVEL = "party_quick_end.txt" //Quick intro, quick reminisce (no debug)

//string LEVEL = "camera_check.txt"

//string LEVEL = kurt.txt

//string LEVEL = "Chunks/w0_limbo.tmx"
//string LEVEL = "Chunks/w1_2_05000_puzzle.tmx"
//string LEVEL = "Chunks/w2_1_06000_action.tmx"
//string LEVEL = "Chunks/w3_2_07000_bad.tmx"
//string LEVEL = "Chunks/w3_1_06000_action.tmx"
//string LEVEL = "Chunks/glue_test_harald_23.tmx"
//string LEVEL = "Chunks/ws_basic_01000_start.tmx"
//string LEVEL = "Chunks/w5_1_02000_intro.tmx"
//string LEVEL = "lab.txt"

//string LEVEL = "Chunks/glue_test_ben_1.tmx"
//string LEVEL = "Chunks/glue_test_ben_2.tmx"
//string LEVEL = "bens_enemy_chunk_test.txt"
//string LEVEL = "Chunks/glue_test_ben_5.tmx"

//string LEVEL = "chunks/glue_test_kurt_1.tmx" 
//string LEVEL = "Chunks/test_machines.tmx"
//string LEVEL = "harrieslevel.txt"
//string LEVEL = "Chunks/w2_2_08000_fintemple.tmx"
//string LEVEL = "Chunks/w1_1_01000_start.tmx"
//string LEVEL = "Chunks/glue_harald_tiktak.tmx"
//string LEVEL = "Chunks/glue_harald_start_test.tmx"
//string LEVEL = "Chunks/glue_test_levelmen.tmx"
//string LEVEL = "Chunks/glue_harald_start_test.tmx"
//string LEVEL = "Chunks/w1_3_03000_topwarp.tmx"
//string LEVEL = "Chunks/glue_test_levelmen.tmx"
//string LEVEL = "Chunks/glue_harald_totem_test.tmx"
//string LEVEL = "Chunks/glue_test_bubble.tmx"
//string LEVEL = "Chunks/glue_test_fins.tmx"
//string LEVEL = "Chunks/w1_1_05000_lmen.tmx"
//string LEVEL = "Chunks/w3_3_07000_chase.tmx"
string LEVEL = "Chunks/w4_3_10000_action.tmx"

string LEVEL_CODEGLUE20 = "chunks/w1_1_01000_start.tmx"
//string LEVEL_CODEGLUE12 = "world_work.txt"
//string LEVEL_CODEGLUE17 = "world_work.txt"
//string LEVEL = "world_work.txt"
//string LEVEL_CODEGLUE20 = "chunks/test_ben_04.tmx"
// the distance that the camera has to move to complete a color transition
// the transition will be finished at the position of the color shift marker in the level.
float COLOR_SHIFT_WIDTH = 160
// same for music eh
float MUSIC_SHIFT_WIDTH = 180